﻿/*
* HyperStat.NET - The minimalist's static website compiler.
* Copyright (C) 2012 Benjamin Brent
* http://www.hyperstat.net/
* http://hyperstat.codeplex.com/
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/
var bifs = "\
vendors = moz webkit o ms official\n\
\n\
// stringify the given arg\n\
\n\
-string(arg)\n\
  type(arg) + ' ' + arg\n\
\n\
// require a color\n\
\n\
require-color(color)\n\
  unless color is a 'color' \n\
    error('RGB or HSL value expected, got a ' + -string(color))\n\
\n\
// require a unit\n\
\n\
require-unit(n)\n\
  unless n is a 'unit'\n\
    error('unit expected, got a ' + -string(n))\n\
\n\
// require a string\n\
\n\
require-string(str)\n\
  unless str is a 'string' or str is a 'ident'\n\
    error('string expected, got a ' + -string(str))\n\
\n\
// apply js Math function\n\
\n\
math(n, fn) \n\
  require-unit(n)\n\
  require-string(fn)\n\
  -math(n, fn)\n\
\n\
// adjust the given color's property by amount\n\
\n\
adjust(color, prop, amount)\n\
  require-color(color)\n\
  require-string(prop)\n\
  require-unit(amount)\n\
  -adjust(color, prop, amount)\n\
\n\
// Math functions\n\
\n\
abs(n) { math(n, 'abs') }\n\
ceil(n) { math(n, 'ceil') }\n\
floor(n) { math(n, 'floor') }\n\
round(n) { math(n, 'round') }\n\
sin(n) { math(n, 'sin') }\n\
cos(n) { math(n, 'cos') }\n\
min(a, b) { a < b ? a : b }\n\
max(a, b) { a > b ? a : b }\n\
PI = -math-prop('PI')\n\
\n\
// return the sum of the given numbers\n\
\n\
sum(nums)\n\
  sum = 0\n\
  sum += n for n in nums\n\
\n\
// return the average of the given numbers\n\
\n\
avg(nums)\n\
  sum(nums) / length(nums)\n\
\n\
// color components\n\
\n\
alpha(color) { component(hsl(color), 'alpha') }\n\
hue(color) { component(hsl(color), 'hue') }\n\
saturation(color) { component(hsl(color), 'saturation') }\n\
lightness(color) { component(hsl(color), 'lightness') }\n\
\n\
// check if n is an odd number\n\
\n\
odd(n)\n\
  1 == n % 2\n\
\n\
// check if n is an even number\n\
\n\
even(n)\n\
  0 == n % 2\n\
\n\
// check if color is light\n\
\n\
light(color)\n\
  lightness(color) >= 50%\n\
\n\
// check if color is dark\n\
\n\
dark(color)\n\
  lightness(color) < 50%\n\
\n\
// desaturate color by amount\n\
\n\
desaturate(color, amount)\n\
  adjust(color, 'saturation', - amount)\n\
\n\
// saturate color by amount\n\
\n\
saturate(color, amount)\n\
  adjust(color, 'saturation', amount)\n\
\n\
// darken by the given amount\n\
\n\
darken(color, amount)\n\
  adjust(color, 'lightness', - amount)\n\
\n\
// lighten by the given amount\n\
\n\
lighten(color, amount)\n\
  adjust(color, 'lightness', amount)\n\
\n\
// decerase opacity by amount\n\
\n\
fade-out(color, amount)\n\
  color - rgba(black, amount)\n\
\n\
// increase opacity by amount\n\
\n\
fade-in(color, amount)\n\
  color + rgba(black, amount)\n\
\n\
// return the last value in the given expr\n\
\n\
last(expr)\n\
  expr[length(expr) - 1]\n\
\n\
// join values with the given delimiter\n\
\n\
join(delim, vals...)\n\
  buf = ''\n\
  vals = vals[0] if length(vals) == 1\n\
  for val, i in vals\n\
    buf += i ? delim + val : val\n\
";

var stylus = (function () {

    __dirname = '';

    function require(p) {

        // begin QUIRKS
        switch (p) {
            case 'visitor/':
            case 'nodes/':
                p += 'index';
                break;
            case 'nodes/extend':
                return function (val) { return val };
            case 'middleware':
                return {};
            case 'debug':
                return function () {
                    return function () { };
                };
            case 'visitor/normalizer':
                var Normalizer = function (ast) {
                    this.ast = ast;
                };

                Normalizer.prototype.normalize = function () {
                    return this.ast;
                };

                return Normalizer;
        }
        // end QUIRKS

        var path = require.resolve(p)
        , mod = require.modules[path];
        if (!mod) throw new Error('failed to require "' + p + '"');
        if (!mod.exports) {
            mod.exports = {};
            mod.call(mod.exports, mod, mod.exports, require.relative(path));
        }
        return mod.exports;
    }

    require.modules = {};

    require.resolve = function (path) {
        var orig = path
        , reg = path + '.js'
        , index = path + '/index.js';
        return require.modules[reg] && reg
        || require.modules[index] && index
        || orig;
    };

    require.register = function (path, fn) {
        require.modules[path] = fn;
    };

    require.relative = function (parent) {
        return function (p) {
            if ('.' != p[0]) return require(p);

            var path = parent.split('/')
            , segs = p.split('/');
            path.pop();

            for (var i = 0; i < segs.length; i++) {
                var seg = segs[i];
                if ('..' == seg) path.pop();
                else if ('.' != seg) path.push(seg);
            }

            return require(path.join('/'));
        };
    };


    require.register("util", function (module, exports, require) {

        exports.inspect = function (str) {
            return str;
        };
    }); // module: util


    require.register("fs", function (module, exports, require) {

        exports.statSync = function () { };
        exports.readFileSync = function () { return ''; };
        exports.stat = function () { };
    }); // module: fs


    require.register("url", function (module, exports, require) {

        exports.parse = function (url) {
            return url;
        };
    }); // module: url


    require.register("debug", function (module, exports, require) {

        exports = function () {
            return function () { };
        };
    }); // module: debug


    require.register("events", function (module, exports, require) {

        var EventEmitter = function () { };
        EventEmitter.prototype.emit = function () { };

        exports.EventEmitter = EventEmitter;
    }); // module: events


    require.register("path.js", function (module, exports, require) {

        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.


        var isWindows = false;


        // resolves . and .. elements in a path array with directory names there
        // must be no slashes, empty elements, or device names (c:\) in the array
        // (so also no leading and trailing slashes - it does not distinguish
        // relative and absolute paths)
        function normalizeArray(parts, allowAboveRoot) {
            // if the path tries to go above the root, `up` ends up > 0
            var up = 0;
            for (var i = parts.length - 1; i >= 0; i--) {
                var last = parts[i];
                if (last == '.') {
                    parts.splice(i, 1);
                } else if (last === '..') {
                    parts.splice(i, 1);
                    up++;
                } else if (up) {
                    parts.splice(i, 1);
                    up--;
                }
            }

            // if the path is allowed to go above the root, restore leading ..s
            if (allowAboveRoot) {
                for (; up--; up) {
                    parts.unshift('..');
                }
            }

            return parts;
        }


        // Regex to split a filename into [*, dir, basename, ext]
        // posix version
        var splitPathRe = /^([\s\S]+\/(?!$)|\/)?((?:[\s\S]+?)?(\.[^.]*)?)$/;

        // path.normalize(path)
        // posix version
        exports.normalize = function (path) {
            var isAbsolute = path.charAt(0) === '/',
      trailingSlash = path.slice(-1) === '/';

            // Normalize the path
            path = normalizeArray(path.split('/').filter(function (p) {
                return !!p;
            }), !isAbsolute).join('/');

            if (!path && !isAbsolute) {
                path = '.';
            }
            if (path && trailingSlash) {
                path += '/';
            }

            return (isAbsolute ? '/' : '') + path;
        };


        // posix version
        exports.join = function () {
            var paths = Array.prototype.slice.call(arguments, 0);
            return exports.normalize(paths.filter(function (p, index) {
                return p && typeof p === 'string';
            }).join('/'));
        };


        // path.relative(from, to)
        // posix version
        exports.relative = function (from, to) {
            from = exports.resolve(from).substr(1);
            to = exports.resolve(to).substr(1);

            function trim(arr) {
                var start = 0;
                for (; start < arr.length; start++) {
                    if (arr[start] !== '') break;
                }

                var end = arr.length - 1;
                for (; end >= 0; end--) {
                    if (arr[end] !== '') break;
                }

                if (start > end) return [];
                return arr.slice(start, end - start + 1);
            }

            var fromParts = trim(from.split('/'));
            var toParts = trim(to.split('/'));

            var length = Math.min(fromParts.length, toParts.length);
            var samePartsLength = length;
            for (var i = 0; i < length; i++) {
                if (fromParts[i] !== toParts[i]) {
                    samePartsLength = i;
                    break;
                }
            }

            var outputParts = [];
            for (var i = samePartsLength; i < fromParts.length; i++) {
                outputParts.push('..');
            }

            outputParts = outputParts.concat(toParts.slice(samePartsLength));

            return outputParts.join('/');
        };


        exports.dirname = function (path) {
            var dir = splitPathRe.exec(path)[1] || '';
            if (!dir) {
                // No dirname
                return '.';
            } else if (dir.length === 1 ||
      (isWindows && dir.length <= 3 && dir.charAt(1) === ':')) {
                // It is just a slash or a drive letter with a slash
                return dir;
            } else {
                // It is a full dirname, strip trailing slash
                return dir.substring(0, dir.length - 1);
            }
        };


        exports.basename = function (path, ext) {
            var f = splitPathRe.exec(path)[2] || '';
            // TODO: make this comparison case-insensitive on windows?
            if (ext && f.substr(-1 * ext.length) === ext) {
                f = f.substr(0, f.length - ext.length);
            }
            return f;
        };


        exports.extname = function (path) {
            return splitPathRe.exec(path)[3] || '';
        };
    }); // module: path.js


    require.register("units.js", function (module, exports, require) {


        /*!
        * Stylus - units
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        module.exports = [
    'em'
  , 'ex'
  , 'px'
  , 'mm'
  , 'cm'
  , 'in'
  , 'pt'
  , 'pc'
  , 'deg'
  , 'rad'
  , 'grad'
  , 'ms'
  , 's'
  , 'Hz'
  , 'kHz'
  , 'rem'
  , '%'
];
    }); // module: units.js


    require.register("colors.js", function (module, exports, require) {


        /*!
        * Stylus - colors
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        module.exports = {
            aliceblue: [240, 248, 255]
  , antiquewhite: [250, 235, 215]
  , aqua: [0, 255, 255]
  , aquamarine: [127, 255, 212]
  , azure: [240, 255, 255]
  , beige: [245, 245, 220]
  , bisque: [255, 228, 196]
  , black: [0, 0, 0]
  , blanchedalmond: [255, 235, 205]
  , blue: [0, 0, 255]
  , blueviolet: [138, 43, 226]
  , brown: [165, 42, 42]
  , burlywood: [222, 184, 135]
  , cadetblue: [95, 158, 160]
  , chartreuse: [127, 255, 0]
  , chocolate: [210, 105, 30]
  , coral: [255, 127, 80]
  , cornflowerblue: [100, 149, 237]
  , cornsilk: [255, 248, 220]
  , crimson: [220, 20, 60]
  , cyan: [0, 255, 255]
  , darkblue: [0, 0, 139]
  , darkcyan: [0, 139, 139]
  , darkgoldenrod: [184, 132, 11]
  , darkgray: [169, 169, 169]
  , darkgreen: [0, 100, 0]
  , darkgrey: [169, 169, 169]
  , darkkhaki: [189, 183, 107]
  , darkmagenta: [139, 0, 139]
  , darkolivegreen: [85, 107, 47]
  , darkorange: [255, 140, 0]
  , darkorchid: [153, 50, 204]
  , darkred: [139, 0, 0]
  , darksalmon: [233, 150, 122]
  , darkseagreen: [143, 188, 143]
  , darkslateblue: [72, 61, 139]
  , darkslategray: [47, 79, 79]
  , darkslategrey: [47, 79, 79]
  , darkturquoise: [0, 206, 209]
  , darkviolet: [148, 0, 211]
  , deeppink: [255, 20, 147]
  , deepskyblue: [0, 191, 255]
  , dimgray: [105, 105, 105]
  , dimgrey: [105, 105, 105]
  , dodgerblue: [30, 144, 255]
  , firebrick: [178, 34, 34]
  , floralwhite: [255, 255, 240]
  , forestgreen: [34, 139, 34]
  , fuchsia: [255, 0, 255]
  , gainsboro: [220, 220, 220]
  , ghostwhite: [248, 248, 255]
  , gold: [255, 215, 0]
  , goldenrod: [218, 165, 32]
  , gray: [128, 128, 128]
  , green: [0, 128, 0]
  , greenyellow: [173, 255, 47]
  , grey: [128, 128, 128]
  , honeydew: [240, 255, 240]
  , hotpink: [255, 105, 180]
  , indianred: [205, 92, 92]
  , indigo: [75, 0, 130]
  , ivory: [255, 255, 240]
  , khaki: [240, 230, 140]
  , lavender: [230, 230, 250]
  , lavenderblush: [255, 240, 245]
  , lawngreen: [124, 252, 0]
  , lemonchiffon: [255, 250, 205]
  , lightblue: [173, 216, 230]
  , lightcoral: [240, 128, 128]
  , lightcyan: [224, 255, 255]
  , lightgoldenrodyellow: [250, 250, 210]
  , lightgray: [211, 211, 211]
  , lightgreen: [144, 238, 144]
  , lightgrey: [211, 211, 211]
  , lightpink: [255, 182, 193]
  , lightsalmon: [255, 160, 122]
  , lightseagreen: [32, 178, 170]
  , lightskyblue: [135, 206, 250]
  , lightslategray: [119, 136, 153]
  , lightslategrey: [119, 136, 153]
  , lightsteelblue: [176, 196, 222]
  , lightyellow: [255, 255, 224]
  , lime: [0, 255, 0]
  , limegreen: [50, 205, 50]
  , linen: [250, 240, 230]
  , magenta: [255, 0, 255]
  , maroon: [128, 0, 0]
  , mediumaquamarine: [102, 205, 170]
  , mediumblue: [0, 0, 205]
  , mediumorchid: [186, 85, 211]
  , mediumpurple: [147, 112, 219]
  , mediumseagreen: [60, 179, 113]
  , mediumslateblue: [123, 104, 238]
  , mediumspringgreen: [0, 250, 154]
  , mediumturquoise: [72, 209, 204]
  , mediumvioletred: [199, 21, 133]
  , midnightblue: [25, 25, 112]
  , mintcream: [245, 255, 250]
  , mistyrose: [255, 228, 225]
  , moccasin: [255, 228, 181]
  , navajowhite: [255, 222, 173]
  , navy: [0, 0, 128]
  , oldlace: [253, 245, 230]
  , olive: [128, 128, 0]
  , olivedrab: [107, 142, 35]
  , orange: [255, 165, 0]
  , orangered: [255, 69, 0]
  , orchid: [218, 112, 214]
  , palegoldenrod: [238, 232, 170]
  , palegreen: [152, 251, 152]
  , paleturquoise: [175, 238, 238]
  , palevioletred: [219, 112, 147]
  , papayawhip: [255, 239, 213]
  , peachpuff: [255, 218, 185]
  , peru: [205, 133, 63]
  , pink: [255, 192, 203]
  , plum: [221, 160, 203]
  , powderblue: [176, 224, 230]
  , purple: [128, 0, 128]
  , red: [255, 0, 0]
  , rosybrown: [188, 143, 143]
  , royalblue: [65, 105, 225]
  , saddlebrown: [139, 69, 19]
  , salmon: [250, 128, 114]
  , sandybrown: [244, 164, 96]
  , seagreen: [46, 139, 87]
  , seashell: [255, 245, 238]
  , sienna: [160, 82, 45]
  , silver: [192, 192, 192]
  , skyblue: [135, 206, 235]
  , slateblue: [106, 90, 205]
  , slategray: [119, 128, 144]
  , slategrey: [119, 128, 144]
  , snow: [255, 255, 250]
  , springgreen: [0, 255, 127]
  , steelblue: [70, 130, 180]
  , tan: [210, 180, 140]
  , teal: [0, 128, 128]
  , thistle: [216, 191, 216]
  , tomato: [255, 99, 71]
  , turquoise: [64, 224, 208]
  , violet: [238, 130, 238]
  , wheat: [245, 222, 179]
  , white: [255, 255, 255]
  , whitesmoke: [245, 245, 245]
  , yellow: [255, 255, 0]
  , yellowgreen: [154, 205, 5]
        };
    }); // module: colors.js


    require.register("errors.js", function (module, exports, require) {


        /*!
        * Stylus - errors
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Expose constructors.
        */

        exports.ParseError = ParseError;
        exports.SyntaxError = SyntaxError;

        /**
        * Inherit from `Error.prototype`.
        */

        SyntaxError.prototype.__proto__ = Error.prototype;

        /**
        * Initialize a new `ParseError` with the given `msg`.
        *
        * @param {String} msg
        * @api private
        */

        function ParseError(msg) {
            this.name = 'ParseError';
            this.message = msg;
            Error.captureStackTrace(this, ParseError);
        }

        /**
        * Inherit from `Error.prototype`.
        */

        ParseError.prototype.__proto__ = Error.prototype;

        /**
        * Initialize a new `SyntaxError` with the given `msg`.
        *
        * @param {String} msg
        * @api private
        */

        function SyntaxError(msg) {
            this.name = 'SyntaxError';
            this.message = msg;
            Error.captureStackTrace(this, ParseError);
        }

        /**
        * Inherit from `Error.prototype`.
        */

        SyntaxError.prototype.__proto__ = Error.prototype;

    }); // module: errors.js


    require.register("functions/index.js", function (module, exports, require) {


        /*!
        * Stylus - Evaluator - built-in functions
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Compiler = require('../visitor/compiler')
  , nodes = require('../nodes')
  , utils = require('../utils')
  , Image = require('./image');

        /**
        * Color component name map.
        */

        var componentMap = {
            red: 'r'
  , green: 'g'
  , blue: 'b'
  , alpha: 'a'
  , hue: 'h'
  , saturation: 's'
  , lightness: 'l'
        };

        /**
        * Color component unit type map.
        */

        var unitMap = {
            hue: 'deg'
  , saturation: '%'
  , lightness: '%'
        };

        /**
        * Color type map.
        */

        var typeMap = {
            red: 'rgba'
  , blue: 'rgba'
  , green: 'rgba'
  , alpha: 'rgba'
  , hue: 'hsla'
  , saturation: 'hsla'
  , lightness: 'hsla'
        };

        /**
        * Convert the given `color` to an `HSLA` node,
        * or h,s,l,a component values.
        *
        * Examples:
        *
        *    hsla(10deg, 50%, 30%, 0.5)
        *    // => HSLA
        *
        *    hsla(#ffcc00)
        *    // => HSLA
        *
        * @param {RGBA|HSLA|Unit} hue
        * @param {Unit} saturation
        * @param {Unit} lightness
        * @param {Unit} alpha
        * @return {HSLA}
        * @api public
        */

        exports.hsla = function hsla(hue, saturation, lightness, alpha) {
            if (alpha && '%' == alpha.type) alpha.val /= 100;
            switch (arguments.length) {
                case 1:
                    utils.assertColor(hue);
                    return hue.hsla;
                default:
                    utils.assertType(hue, 'unit', 'hue');
                    utils.assertType(saturation, 'unit', 'saturation');
                    utils.assertType(lightness, 'unit', 'lightness');
                    utils.assertType(alpha, 'unit', 'alpha');
                    return new nodes.HSLA(
          hue.val
        , saturation.val
        , lightness.val
        , alpha.val);
            }
        };

        /**
        * Convert the given `color` to an `HSLA` node,
        * or h,s,l component values.
        *
        * Examples:
        *
        *    hsl(10, 50, 30)
        *    // => HSLA
        *
        *    hsl(#ffcc00)
        *    // => HSLA
        *
        * @param {Unit|HSLA|RGBA} hue
        * @param {Unit} saturation
        * @param {Unit} lightness
        * @return {HSLA}
        * @api public
        */

        exports.hsl = function hsl(hue, saturation, lightness) {
            if (1 == arguments.length) {
                utils.assertColor(hue, 'color');
                return hue.hsla;
            } else {
                return exports.hsla(
        hue
      , saturation
      , lightness
      , new nodes.Unit(1));
            }
        };

        /**
        * Return type of `node`.
        *
        * Examples:
        * 
        *    type(12)
        *    // => 'unit'
        *
        *    type(#fff)
        *    // => 'color'
        *
        *    type(type)
        *    // => 'function'
        *
        *    type(unbound)
        *    typeof(unbound)
        *    type-of(unbound)
        *    // => 'ident'
        *
        * @param {Node} node
        * @return {String}
        * @api public
        */

        exports.type =
exports['typeof'] =
exports['type-of'] = function type(node) {
    utils.assertPresent(node, 'expression');
    return node.nodeName;
};

        /**
        * Return component `name` for the given `color`.
        *
        * @param {RGBA|HSLA} color
        * @param {String} na,e
        * @return {Unit}
        * @api public
        */

        exports.component = function component(color, name) {
            utils.assertColor(color, 'color');
            utils.assertString(name, 'name');
            var name = name.string
    , unit = unitMap[name]
    , type = typeMap[name]
    , name = componentMap[name];
            if (!name) throw new Error('invalid color component "' + name + '"');
            return new nodes.Unit(color[type][name], unit);
        };

        /**
        * Return the red component of the given `color`.
        *
        * Examples:
        *
        *    red(#c00)
        *    // => 204
        *
        * @param {RGBA|HSLA} color
        * @return {Unit}
        * @api public
        */

        exports.red = function red(color) {
            return exports.component(color, new nodes.String('red'));
        };

        /**
        * Return the green component of the given `color`.
        *
        * Examples:
        *
        *    green(#0c0)
        *    // => 204
        *
        * @param {RGBA|HSLA} color
        * @return {Unit}
        * @api public
        */

        exports.green = function green(color) {
            return exports.component(color, new nodes.String('green'));
        };

        /**
        * Return the blue component of the given `color`.
        *
        * Examples:
        *
        *    blue(#00c)
        *    // => 204
        *
        * @param {RGBA|HSLA} color
        * @return {Unit}
        * @api public
        */

        exports.blue = function blue(color) {
            return exports.component(color, new nodes.String('blue'));
        };

        /**
        * Return a `RGBA` from the r,g,b,a channels.
        *
        * Examples:
        *
        *    rgba(255,0,0,0.5)
        *    // => rgba(255,0,0,0.5)
        *
        *    rgba(255,0,0,1)
        *    // => #ff0000
        *
        *    rgba(#ffcc00, 0.5)
        *    // rgba(255,204,0,0.5)
        *
        * @param {Unit|RGBA|HSLA} red
        * @param {Unit} green
        * @param {Unit} blue
        * @param {Unit} alpha
        * @return {RGBA}
        * @api public
        */

        exports.rgba = function rgba(red, green, blue, alpha) {
            if (alpha && '%' == alpha.type) alpha.val /= 100;
            switch (arguments.length) {
                case 1:
                    utils.assertColor(red);
                    var color = red.rgba;
                    return new nodes.RGBA(
          color.r
        , color.g
        , color.b
        , color.a);
                case 2:
                    utils.assertColor(red);
                    var color = red.rgba;
                    utils.assertType(green, 'unit', 'alpha');
                    return new nodes.RGBA(
          color.r
        , color.g
        , color.b
        , green.val);
                default:
                    utils.assertType(red, 'unit', 'red');
                    utils.assertType(green, 'unit', 'green');
                    utils.assertType(blue, 'unit', 'blue');
                    utils.assertType(alpha, 'unit', 'alpha');
                    var r = '%' == red.type ? Math.round(red.val * 2.55) : red.val;
                    var g = '%' == green.type ? Math.round(green.val * 2.55) : green.val;
                    var b = '%' == blue.type ? Math.round(blue.val * 2.55) : blue.val;
                    return new nodes.RGBA(
          r
        , g
        , b
        , alpha.val);
            }
        };

        /**
        * Return a `RGBA` from the r,g,b channels.
        *
        * Examples:
        *
        *    rgb(255,204,0)
        *    // => #ffcc00
        *
        *    rgb(#fff)
        *    // => #fff
        *
        * @param {Unit|RGBA|HSLA} red
        * @param {Unit} green
        * @param {Unit} blue
        * @return {RGBA}
        * @api public
        */

        exports.rgb = function rgb(red, green, blue) {
            switch (arguments.length) {
                case 1:
                    utils.assertColor(red);
                    var color = red.rgba;
                    return new nodes.RGBA(
          color.r
        , color.g
        , color.b
        , 1);
                default:
                    return exports.rgba(
          red
        , green
        , blue
        , new nodes.Unit(1));
            }
        };

        /**
        * Unquote the given `str`.
        *
        * Examples:
        *
        *    unquote("sans-serif")
        *    // => sans-serif
        *
        *    unquote(sans-serif)
        *    // => sans-serif
        *
        * @param {String|Ident} string
        * @return {Literal}
        * @api public
        */

        exports.unquote = function unquote(string) {
            utils.assertString(string, 'string');
            return new nodes.Literal(string.string);
        };

        /**
        * Assign `type` to the given `unit` or return `unit`'s type.
        *
        * @param {Unit} unit
        * @param {String|Ident} type
        * @return {Unit}
        * @api public
        */

        exports.unit = function unit(unit, type) {
            utils.assertType(unit, 'unit', 'unit');

            // Assign
            if (type) {
                utils.assertString(type, 'type');
                return new nodes.Unit(unit.val, type.string);
            } else {
                return unit.type || '';
            }
        };

        /**
        * Lookup variable `name` or return Null.
        *
        * @param {String} name
        * @return {Mixed}
        * @api public
        */

        exports.lookup = function lookup(name) {
            utils.assertType(name, 'string', 'name');
            var node = this.lookup(name.val);
            if (!node) return nodes['null'];
            return this.visit(node);
        };

        /**
        * Perform `op` on the `left` and `right` operands.
        *
        * @param {String} op
        * @param {Node} left
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        exports.operate = function operate(op, left, right) {
            utils.assertType(op, 'string', 'op');
            utils.assertPresent(left, 'left');
            utils.assertPresent(right, 'right');
            return left.operate(op.val, right);
        };

        /**
        * Test if `val` matches the given `pattern`.
        *
        * Examples:
        *
        *     match('^foo(bar)?', foo)
        *     match('^foo(bar)?', foobar)
        *     match('^foo(bar)?', 'foo')
        *     match('^foo(bar)?', 'foobar')
        *     // => true
        *
        *     match('^foo(bar)?', 'bar')
        *     // => false
        *
        * @param {String} pattern
        * @param {String|Ident} val
        * @return {Boolean}
        * @api public
        */

        exports.match = function match(pattern, val) {
            utils.assertType(pattern, 'string', 'pattern');
            utils.assertString(val, 'val');
            var re = new RegExp(pattern.val);
            return nodes.Boolean(re.test(val.string));
        };

        /**
        * Return length of the given `expr`.
        *
        * @param {Expression} expr
        * @return {Unit}
        * @api public
        */

        (exports.length = function length(expr) {
            if (expr) {
                return expr.nodes
      ? utils.unwrap(expr).nodes.length
      : 1;
            }
            return 0;
        }).raw = true;

        /**
        * Inspect the given `expr`.
        *
        * @param {Expression} expr
        * @api public
        */

        (exports.p = function p() {
            [ ].slice.call(arguments).forEach(function (expr) {
                expr = utils.unwrap(expr);
                if (!expr.nodes.length) return;
                console.log('\u001C[90minspect:\u001C[0m %s', expr.toString().replace(/^\(|\)$/g, ''));
            })
            return nodes['null'];
        }).raw = true;

        /**
        * Throw an error with the given `msg`.
        *
        * @param {String} msg
        * @api public
        */

        exports.error = function error(msg) {
            utils.assertType(msg, 'string', 'msg');
            throw new Error(msg.val);
        };

        /**
        * Warn with the given `msg` prefixed by "Warning: ".
        *
        * @param {String} msg
        * @api public
        */

        exports.warn = function warn(msg) {
            utils.assertType(msg, 'string', 'msg');
            console.warn('Warning: %s', msg.val);
            return nodes['null'];
        };

        /**
        * Output stack trace.
        *
        * @api public
        */

        exports.trace = function trace() {
            console.log(this.stack);
            return nodes['null'];
        };

        /**
        * Push the given args to `expr`.
        *
        * @param {Expression} expr
        * @param {Node} ...
        * @return {Unit}
        * @api public
        */

        (exports.push = exports.append = function (expr) {
            expr = utils.unwrap(expr);
            for (var i = 1, len = arguments.length; i < len; ++i) {
                expr.nodes.push(utils.unwrap(arguments[i]));
            }
            return expr.nodes.length;
        }).raw = true;

        /**
        * Unshift the given args to `expr`.
        *
        * @param {Expression} expr
        * @param {Node} ...
        * @return {Unit}
        * @api public
        */

        (exports.unshift = exports.prepend = function (expr) {
            expr = utils.unwrap(expr);
            for (var i = 1, len = arguments.length; i < len; ++i) {
                expr.nodes.unshift(utils.unwrap(arguments[i]));
            }
            return expr.nodes.length;
        }).raw = true;

        /**
        * Return a `Literal` with the given `fmt`, and
        * variable number of arguments.
        *
        * @param {String} fmt
        * @param {Node} ...
        * @return {Literal}
        * @api public
        */

        (exports.s = function s(fmt) {
            fmt = utils.unwrap(fmt).nodes[0];
            utils.assertString(fmt);
            var self = this
    , str = fmt.string
    , args = arguments
    , i = 1;

            // format
            str = str.replace(/%(s|d)/g, function (_, specifier) {
                var arg = args[i++] || nodes['null'];
                switch (specifier) {
                    case 's':
                        return new Compiler(arg, self.options).compile();
                    case 'd':
                        arg = utils.unwrap(arg).first;
                        if ('unit' != arg.nodeName) throw new Error('%d requires a unit');
                        return arg.val;
                }
            });

            return new nodes.Literal(str);
        }).raw = true;

        /**
        * Return the opposites of the given `positions`.
        *
        * Examples:
        *
        *    opposite-position(top left)
        *    // => bottom right
        *
        * @param {Expression} positions
        * @return {Expression}
        * @api public
        */

        (exports['opposite-position'] = function oppositePosition(positions) {
            var expr = [];
            utils.unwrap(positions).nodes.forEach(function (pos, i) {
                utils.assertString(pos, 'position ' + i);
                pos = (function () {
                    switch (pos.string) {
                        case 'top': return 'bottom';
                        case 'bottom': return 'top';
                        case 'left': return 'right';
                        case 'right': return 'left';
                        case 'center': return 'center';
                        default: throw new Error('invalid position ' + pos);
                    }
                })();
                expr.push(new nodes.Literal(pos));
            });
            return expr;
        }).raw = true;

        /**
        * Return the width and height of the given `img` path.
        *
        * Examples:
        *
        *    image-size('foo.png')
        *    // => 200px 100px
        *
        *    image-size('foo.png')[0]
        *    // => 200px
        *
        *    image-size('foo.png')[1]
        *    // => 100px
        *
        * @param {String} img
        * @return {Expression}
        * @api public
        */

        exports['image-size'] = function imageSize(img) {
            utils.assertType(img, 'string', 'img');
            var img = new Image(this, img.string);

            // Read size
            img.open();
            var size = img.size();
            img.close();

            // Return (w h)
            var expr = [];
            expr.push(new nodes.Unit(size[0], 'px'));
            expr.push(new nodes.Unit(size[1], 'px'));

            return expr;
        };

        /**
        * Apply Math `fn` to `n`.
        *
        * @param {Unit} n
        * @param {String} fn
        * @return {Unit}
        * @api private
        */

        exports['-math'] = function math(n, fn) {
            return new nodes.Unit(Math[fn.string](n.val), n.type);
        };

        /**
        * Get Math `prop`.
        *
        * @param {String} prop
        * @return {Unit}
        * @api private
        */

        exports['-math-prop'] = function math(prop) {
            return new nodes.Unit(Math[prop.string]);
        };

        /**
        * Buffer the given js `str`.
        *
        * @param {String} str
        * @return {JSLiteral}
        * @api private
        */

        exports.js = function js(str) {
            utils.assertString(str, 'str');
            return new nodes.JSLiteral(str.val);
        };

        /**
        * Adjust HSL `color` `prop` by `amount`.
        *
        * @param {RGBA|HSLA} color
        * @param {String} prop
        * @param {Unit} amount
        * @return {RGBA}
        * @api private
        */

        exports['-adjust'] = function adjust(color, prop, amount) {
            var hsl = color.hsla.clone();
            prop = { hue: 'h', saturation: 's', lightness: 'l'}[prop.string];
            if (!prop) throw new Error('invalid adjustment property');
            var val = amount.val;
            if ('%' == amount.type) {
                val = 'l' == prop && val > 0
      ? (100 - hsl[prop]) * val / 100
      : hsl[prop] * (val / 100);
            }
            hsl[prop] += val;
            return hsl.rgba;
        };

        /**
        * Return a clone of the given `expr`.
        *
        * @param {Expression} expr
        * @return {Node}
        * @api public
        */

        (exports.clone = function clone(expr) {
            utils.assertPresent(expr, 'expr');
            return expr.clone();
        }).raw = true;

        /**
        * Add property `name` with the given `expr`
        * to the mixin-able block.
        *
        * @param {String|Ident|Literal} name
        * @param {Expression} expr
        * @return {Property}
        * @api public
        */

        (exports['add-property'] = function addProperty(name, expr) {
            utils.assertType(name, 'expression', 'name');
            name = utils.unwrap(name).first;
            utils.assertString(name, 'name');
            utils.assertType(expr, 'expression', 'expr');
            var prop = new nodes.Property([name], expr);
            var block = this.closestBlock;

            var len = block.nodes.length
    , head = block.nodes.slice(0, block.index)
    , tail = block.nodes.slice(block.index++, len);
            head.push(prop);
            block.nodes = head.concat(tail);

            return prop;
        }).raw = true;
    }); // module: functions/index.js


    require.register("functions/image.js", function (module, exports, require) {



        /*!
        * Stylus - plugin - url
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var utils = require('../utils')
  , nodes = require('../nodes')
  , fs = require('fs');

        /**
        * Initialize a new `Image` with the given `ctx` and `path.
        *
        * @param {Evaluator} ctx
        * @param {String} path
        * @api private
        */

        var Image = module.exports = function Image(ctx, path) {
            this.ctx = ctx;
            this.path = utils.lookup(path, ctx.paths);
            if (!this.path) throw new Error('failed to locate file ' + path);
        };

        /**
        * Open the image for reading.
        *
        * @api private
        */

        Image.prototype.open = function () {
            this.fd = fs.openSync(this.path, 'r');
        };

        /**
        * Close the file.
        *
        * @api private
        */

        Image.prototype.close = function () {
            if (this.fd) fs.closeSync(this.fd);
        };

        /**
        * Return the type of image, supports:
        *
        *  - gif
        *  - png
        *  - jpeg
        *
        * @return {String}
        * @api private
        */

        Image.prototype.type = function () {
            var type
    , buf = new Buffer(4);

            fs.readSync(this.fd, buf, 0, 4, 0);

            // GIF
            if (0x47 == buf[0] && 0x49 == buf[1] && 0x46 == buf[2]) type = 'gif';

            // PNG
            else if (0x50 == buf[1] && 0x4E == buf[2] && 0x47 == buf[3]) type = 'png';

            // JPEG
            else if (0xff == buf[0] && 0xd8 == buf[1]) type = 'jpeg';

            return type;
        };

        /**
        * Return image dimensions `[width, height]`.
        *
        * @return {Array}
        * @api private
        */

        Image.prototype.size = function () {
            var type = this.type()
    , width
    , height
    , buf;

            function uint16(b) { return b[1] << 8 | b[0]; }
            function uint32(b) { return b[0] << 24 | b[1] << 16 | b[2] << 8 | b[3]; }

            // Determine dimensions
            switch (type) {
                case 'jpeg':
                    throw new Error('image-size() jpeg support not yet implemented');
                    break;
                case 'png':
                    buf = new Buffer(8);
                    // IHDR chunk width / height uint32_t big-endian
                    fs.readSync(this.fd, buf, 0, 8, 16);
                    width = uint32(buf);
                    height = uint32(buf.slice(4, 8));
                    break;
                case 'gif':
                    buf = new Buffer(4);
                    // width / height uint16_t little-endian
                    fs.readSync(this.fd, buf, 0, 4, 6);
                    width = uint16(buf);
                    height = uint16(buf.slice(2, 4));
                    break;
            }

            if ('number' != typeof width) throw new Error('failed to find width of "' + this.path + '"');
            if ('number' != typeof height) throw new Error('failed to find height of "' + this.path + '"');

            return [width, height];
        };
    }); // module: functions/image.js


    require.register("functions/url.js", function (module, exports, require) {


        /*!
        * Stylus - plugin - url
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Compiler = require('../visitor/compiler')
  , nodes = require('../nodes')
  , parse = require('url').parse
  , extname = require('path').extname
  , utils = require('../utils')
  , fs = require('fs');

        /**
        * Mime table.
        */

        var mimes = {
            '.gif': 'image/gif'
  , '.png': 'image/png'
  , '.jpg': 'image/jpeg'
  , '.jpeg': 'image/jpeg'
  , '.svg': 'image/svg+xml'
        };

        /**
        * Return a url() function with the given `options`.
        *
        * Options:
        *
        *    - `limit` bytesize limit defaulting to 30Kb
        *    - `paths` image resolution path(s), merged with general lookup paths
        *
        * Examples:
        *
        *    stylus(str)
        *      .set('filename', __dirname + '/css/test.styl')
        *      .define('url', stylus.url({ paths: [__dirname + '/public'] }))
        *      .render(function(err, css){ ... })
        *
        * @param {Object} options
        * @return {Function}
        * @api public
        */

        module.exports = function (options) {
            options = options || {};

            var sizeLimit = options.limit || 30000
    , _paths = options.paths || [];

            function url(url) {
                // Compile the url
                var compiler = new Compiler(url);
                compiler.isURL = true;
                var url = url.nodes.map(function (node) {
                    return compiler.visit(node);
                }).join('');

                // Parse literal 
                var url = parse(url)
      , ext = extname(url.pathname)
      , mime = mimes[ext]
      , literal = new nodes.Literal('url("' + url.href + '")')
      , paths = _paths.concat(this.paths)
      , founds
      , buf;

                // Not supported
                if (!mime) return literal;

                // Absolute
                if (url.protocol) return literal;

                // Lookup
                var found = utils.lookup(url.pathname, paths);

                // Failed to lookup
                if (!found) return literal;

                // Read data
                buf = fs.readFileSync(found);

                // To large
                if (buf.length > sizeLimit) return literal;

                // Encode
                return new nodes.Literal('url("data:' + mime + ';base64,' + buf.toString('base64') + '")');
            };

            url.raw = true;
            return url;
        };
    }); // module: functions/url.js


    require.register("lexer.js", function (module, exports, require) {


        /*!
        * Stylus - Lexer
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Token = require('./token')
  , nodes = require('./nodes')
  , errors = require('./errors')
  , units = require('./units');

        /**
        * Expose `Lexer`.
        */

        exports = module.exports = Lexer;

        /**
        * Operator aliases.
        */

        var alias = {
            'and': '&&'
  , 'or': '||'
  , 'is': '=='
  , 'isnt': '!='
  , 'is not': '!='
  , ':=': '?='
        };

        /**
        * Units.
        */

        units = units.join('|');

        /**
        * Unit RegExp.
        */

        var unit = new RegExp('^(-)?(\\d+\\.\\d+|\\d+|\\.\\d+)(' + units + ')?[ \\t]*');

        /**
        * Initialize a new `Lexer` with the given `str` and `options`.
        *
        * @param {String} str
        * @param {Object} options
        * @api private
        */

        function Lexer(str, options) {
            options = options || {};
            this.stash = [];
            this.indentStack = [];
            this.indentRe = null;
            this.lineno = 1;

            function comment(str, val, offset, s) {
                return s.lastIndexOf('/*', offset) > s.lastIndexOf('*/', offset)
      ? str
      : val;
            };

            this.str = str
    .replace(/\r\n?/g, '\n')
    .replace(/\\ *\n/g, ' ')
    .replace(/([,:(]) *\n\s*/g, comment)
    .replace(/\s*\n *([,)])/g, comment);
        };

        /**
        * Lexer prototype.
        */

        Lexer.prototype = {

            /**
            * Custom inspect.
            */

            inspect: function () {
                var tok
      , tmp = this.str
      , buf = [];
                while ('eos' != (tok = this.next()).type) {
                    buf.push(tok.inspect());
                }
                this.str = tmp;
                this.prevIndents = 0;
                return buf.concat(tok.inspect()).join('\n');
            },

            /**
            * Lookahead `n` tokens.
            *
            * @param {Number} n
            * @return {Object}
            * @api private
            */

            lookahead: function (n) {
                var fetch = n - this.stash.length;
                while (fetch-- > 0) this.stash.push(this.advance());
                return this.stash[--n];
            },

            /**
            * Consume the given `len`.
            *
            * @param {Number|Array} len
            * @api private
            */

            skip: function (len) {
                this.str = this.str.substr(Array.isArray(len)
      ? len[0].length
      : len);
            },

            /**
            * Fetch next token including those stashed by peek.
            *
            * @return {Token}
            * @api private
            */

            next: function () {
                var tok = this.stashed() || this.advance();
                switch (tok.type) {
                    case 'newline':
                    case 'indent':
                        ++this.lineno;
                        break;
                    case 'outdent':
                        if ('outdent' != this.prev.type) ++this.lineno;
                }
                this.prev = tok;
                tok.lineno = this.lineno;
                return tok;
            },

            /**
            * Fetch next token.
            *
            * @return {Token}
            * @api private
            */

            advance: function () {
                return this.eos()
      || this['null']()
      || this.sep()
      || this.keyword()
      || this.urlchars()
      || this.atrule()
      || this.scope()
      || this['extends']()
      || this.media()
      || this.comment()
      || this.newline()
      || this.escaped()
      || this.important()
      || this.literal()
      || this['function']()
      || this.brace()
      || this.paren()
      || this.color()
      || this.string()
      || this.unit()
      || this.namedop()
      || this['boolean']()
      || this.ident()
      || this.op()
      || this.space()
      || this.selector();
            },

            /**
            * Lookahead a single token.
            *
            * @return {Token}
            * @api private
            */

            peek: function () {
                return this.lookahead(1);
            },

            /**
            * Return the next possibly stashed token.
            *
            * @return {Token}
            * @api private
            */

            stashed: function () {
                return this.stash.shift();
            },

            /**
            * EOS | trailing outdents.
            */

            eos: function () {
                if (this.str.length) return;
                if (this.indentStack.length) {
                    this.indentStack.shift();
                    return new Token('outdent');
                } else {
                    return new Token('eos');
                }
            },

            /**
            * url char
            */

            urlchars: function () {
                var captures;
                if (!this.isURL) return;
                if (captures = /^[\/:@.;?&=*!,<>#%0-9]+/.exec(this.str)) {
                    this.skip(captures);
                    return new Token('literal', new nodes.Literal(captures[0]));
                }
            },

            /**
            * ';' [ \t]*
            */

            sep: function () {
                var captures;
                if (captures = /^;[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    return new Token(';');
                }
            },

            /**
            * ' '+
            */

            space: function () {
                var captures;
                if (captures = /^([ \t]+)/.exec(this.str)) {
                    this.skip(captures);
                    return new Token('space');
                }
            },

            /**
            * '\\' . ' '*
            */

            escaped: function () {
                var captures;
                if (captures = /^\\(.)[ \t]*/.exec(this.str)) {
                    var c = captures[1];
                    this.skip(captures);
                    return new Token('ident', new nodes.Literal(c));
                }
            },

            /**
            * '@css' ' '* '{' .* '}' ' '*
            */

            literal: function () {
                // HACK attack !!!
                var captures;
                if (captures = /^@css[ \t]*\{/.exec(this.str)) {
                    this.skip(captures);
                    var c
        , braces = 1
        , css = '';
                    while (c = this.str[0]) {
                        this.str = this.str.substr(1);
                        switch (c) {
                            case '{': ++braces; break;
                            case '}': --braces; break;
                        }
                        css += c;
                        if (!braces) break;
                    }
                    css = css.replace(/\s*}$/, '');
                    return new Token('literal', new nodes.Literal(css));
                }
            },

            /**
            * '!important' ' '*
            */

            important: function () {
                var captures;
                if (captures = /^!important[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    return new Token('ident', new nodes.Literal('!important'));
                }
            },

            /**
            * '{' | '}'
            */

            brace: function () {
                var captures;
                if (captures = /^([{}])/.exec(this.str)) {
                    this.skip(1);
                    var brace = captures[1];
                    return new Token(brace, brace);
                }
            },

            /**
            * '(' | ')' ' '*
            */

            paren: function () {
                var captures;
                if (captures = /^([()])([ \t]*)/.exec(this.str)) {
                    var paren = captures[1];
                    this.skip(captures);
                    if (')' == paren) this.isURL = false;
                    var tok = new Token(paren, paren);
                    tok.space = captures[2];
                    return tok;
                }
            },

            /**
            * 'null'
            */

            'null': function () {
                var captures;
                if (captures = /^(null)\b[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    return new Token('null', nodes['null']);
                }
            },

            /**
            *   'if'
            * | 'else'
            * | 'unless'
            * | 'return'
            * | 'for'
            * | 'in'
            */

            keyword: function () {
                var captures;
                if (captures = /^(return|if|else|unless|for|in)\b[ \t]*/.exec(this.str)) {
                    var keyword = captures[1];
                    this.skip(captures);
                    return new Token(keyword, keyword);
                }
            },

            /**
            *   'not'
            * | 'and'
            * | 'or'
            * | 'is'
            * | 'is not'
            * | 'isnt'
            * | 'is a'
            * | 'is defined'
            */

            namedop: function () {
                var captures;
                if (captures = /^(not|and|or|is a|is defined|isnt|is not|is)(?!-)\b([ \t]*)/.exec(this.str)) {
                    var op = captures[1];
                    this.skip(captures);
                    op = alias[op] || op;
                    var tok = new Token(op, op);
                    tok.space = captures[2];
                    return tok;
                }
            },

            /**
            *   ','
            * | '+'
            * | '+='
            * | '-'
            * | '-='
            * | '*'
            * | '*='
            * | '/'
            * | '/='
            * | '%'
            * | '%='
            * | '**'
            * | '!'
            * | '&'
            * | '&&'
            * | '||'
            * | '>'
            * | '>='
            * | '<'
            * | '<='
            * | '='
            * | '=='
            * | '!='
            * | '!'
            * | '~'
            * | '?='
            * | ':='
            * | '?'
            * | ':'
            * | '['
            * | ']'
            * | '..'
            * | '...'
            */

            op: function () {
                var captures;
                if (captures = /^([.]{2,3}|&&|\|\||[!<>=?:]=|\*\*|[-+*\/%]=?|[,=?:!~<>&\[\]])([ \t]*)/.exec(this.str)) {
                    var op = captures[1];
                    this.skip(captures);
                    op = alias[op] || op;
                    var tok = new Token(op, op);
                    tok.space = captures[2];
                    return tok;
                }
            },

            /**
            * '@extends' ([^{\n]+)
            */

            'extends': function () {
                var captures;
                if (captures = /^@extends?[ \t]*([^\/{\n;]+)/.exec(this.str)) {
                    this.skip(captures);
                    return new Token('extend', captures[1].trim());
                }
            },

            /**
            * '@media' ([^{\n]+)
            */

            media: function () {
                var captures;
                if (captures = /^@media[ \t]*([^\/{\n]+)/.exec(this.str)) {
                    this.skip(captures);
                    return new Token('media', captures[1].trim());
                }
            },

            /**
            * '@scope' ([^{\n]+)
            */

            scope: function () {
                var captures;
                if (captures = /^@scope[ \t]*([^\/{\n]+)/.exec(this.str)) {
                    this.skip(captures);
                    return new Token('scope', captures[1].trim());
                }
            },

            /**
            * '@' ('import' | 'keyframes' | 'charset' | 'page' | 'font-face')
            */

            atrule: function () {
                var captures;
                if (captures = /^@(import|(?:-(\w+)-)?keyframes|charset|font-face|page)[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    var vendor = captures[2]
        , type = captures[1];
                    if (vendor) type = 'keyframes';
                    return new Token(type, vendor);
                }
            },

            /**
            * '//' *
            */

            comment: function () {
                // Single line
                if ('/' == this.str[0] && '/' == this.str[1]) {
                    var end = this.str.indexOf('\n');
                    if (-1 == end) end = this.str.length;
                    this.skip(end);
                    return this.advance();
                }

                // Multi-line
                if ('/' == this.str[0] && '*' == this.str[1]) {
                    var end = this.str.indexOf('*/');
                    if (-1 == end) end = this.str.length;
                    var str = this.str.substr(0, end + 2)
        , lines = str.split('\n').length - 1
        , suppress = true;
                    this.lineno += lines;
                    this.skip(end + 2);
                    // output
                    if ('!' == str[2]) {
                        str = str.replace('*!', '*');
                        suppress = false;
                    }
                    return new Token('comment', new nodes.Comment(str, suppress));
                }
            },

            /**
            * 'true' | 'false'
            */

            'boolean': function () {
                var captures;
                if (captures = /^(true|false)\b([ \t]*)/.exec(this.str)) {
                    var val = nodes.Boolean('true' == captures[1]);
                    this.skip(captures);
                    var tok = new Token('boolean', val);
                    tok.space = captures[2];
                    return tok;
                }
            },

            /**
            * -*[_a-zA-Z$] [-\w\d$]* '('
            */

            'function': function () {
                var captures;
                if (captures = /^(-*[_a-zA-Z$][-\w\d$]*)\(([ \t]*)/.exec(this.str)) {
                    var name = captures[1];
                    this.skip(captures);
                    this.isURL = 'url' == name;
                    var tok = new Token('function', new nodes.Ident(name));
                    tok.space = captures[2];
                    return tok;
                }
            },

            /**
            * -*[_a-zA-Z$] [-\w\d$]*
            */

            ident: function () {
                var captures;
                if (captures = /^(@)?(-*[_a-zA-Z$][-\w\d$]*)/.exec(this.str)) {
                    var at = captures[1]
        , name = captures[2]
        , id = new nodes.Ident(name);
                    this.skip(captures);
                    id.property = !!at;
                    return new Token('ident', id);
                }
            },

            /**
            * '\n' ' '+
            */

            newline: function () {
                var captures, re;

                // we have established the indentation regexp
                if (this.indentRe) {
                    captures = this.indentRe.exec(this.str);
                    // figure out if we are using tabs or spaces
                } else {
                    // try tabs
                    re = /^\n([\t]*)[ \t]*/;
                    captures = re.exec(this.str);

                    // nope, try spaces
                    if (captures && !captures[1].length) {
                        re = /^\n([ \t]*)/;
                        captures = re.exec(this.str);
                    }

                    // established
                    if (captures && captures[1].length) this.indentRe = re;
                }


                if (captures) {
                    var tok
        , indents = captures[1].length;

                    this.skip(captures);
                    if (this.str[0] === ' ' || this.str[0] === '\t') {
                        throw new errors.SyntaxError('Invalid indentation. You can use tabs or spaces to indent, but not both.');
                    }

                    // Reset state
                    this.isVariable = false;

                    // Blank line
                    if ('\n' == this.str[0]) {
                        ++this.lineno;
                        return this.advance();
                    }

                    // Outdent
                    if (this.indentStack.length && indents < this.indentStack[0]) {
                        while (this.indentStack.length && this.indentStack[0] > indents) {
                            this.stash.push(new Token('outdent'));
                            this.indentStack.shift();
                        }
                        tok = this.stash.pop();
                        // Indent
                    } else if (indents && indents != this.indentStack[0]) {
                        this.indentStack.unshift(indents);
                        tok = new Token('indent');
                        // Newline
                    } else {
                        tok = new Token('newline');
                    }

                    return tok;
                }
            },

            /**
            * '-'? (digit+ | digit* '.' digit+) unit
            */

            unit: function () {
                var captures;
                if (captures = unit.exec(this.str)) {
                    this.skip(captures);
                    var n = parseFloat(captures[2]);
                    if ('-' == captures[1]) n = -n;
                    var node = new nodes.Unit(n, captures[3]);
                    return new Token('unit', node);
                }
            },

            /**
            * '"' [^"]+ '"' | "'"" [^']+ "'"
            */

            string: function () {
                var captures;
                if (captures = /^("[^"]*"|'[^']*')[ \t]*/.exec(this.str)) {
                    var str = captures[1]
        , quote = captures[0][0];
                    this.skip(captures);
                    str = str.slice(1, -1).replace(/\\n/g, '\n');
                    return new Token('string', new nodes.String(str, quote));
                }
            },

            /**
            * #rrggbbaa | #rrggbb | #rgba | #rgb | #nn | #n
            */

            color: function () {
                return this.rrggbbaa()
      || this.rrggbb()
      || this.rgba()
      || this.rgb()
      || this.nn()
      || this.n()
            },

            /**
            * #n
            */

            n: function () {
                var captures;
                if (captures = /^#([a-fA-F0-9]{1})[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    var n = parseInt(captures[1] + captures[1], 16)
        , color = new nodes.RGBA(n, n, n, 1);
                    color.raw = captures[0];
                    return new Token('color', color);
                }
            },

            /**
            * #nn
            */

            nn: function () {
                var captures;
                if (captures = /^#([a-fA-F0-9]{2})[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    var n = parseInt(captures[1], 16)
        , color = new nodes.RGBA(n, n, n, 1);
                    color.raw = captures[0];
                    return new Token('color', color);
                }
            },

            /**
            * #rgb
            */

            rgb: function () {
                var captures;
                if (captures = /^#([a-fA-F0-9]{3})[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    var rgb = captures[1]
        , r = parseInt(rgb[0] + rgb[0], 16)
        , g = parseInt(rgb[1] + rgb[1], 16)
        , b = parseInt(rgb[2] + rgb[2], 16)
        , color = new nodes.RGBA(r, g, b, 1);
                    color.raw = captures[0];
                    return new Token('color', color);
                }
            },

            /**
            * #rgba
            */

            rgba: function () {
                var captures;
                if (captures = /^#([a-fA-F0-9]{4})[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    var rgb = captures[1]
        , r = parseInt(rgb[0] + rgb[0], 16)
        , g = parseInt(rgb[1] + rgb[1], 16)
        , b = parseInt(rgb[2] + rgb[2], 16)
        , a = parseInt(rgb[3] + rgb[3], 16)
        , color = new nodes.RGBA(r, g, b, a / 255);
                    color.raw = captures[0];
                    return new Token('color', color);
                }
            },

            /**
            * #rrggbb
            */

            rrggbb: function () {
                var captures;
                if (captures = /^#([a-fA-F0-9]{6})[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    var rgb = captures[1]
        , r = parseInt(rgb.substr(0, 2), 16)
        , g = parseInt(rgb.substr(2, 2), 16)
        , b = parseInt(rgb.substr(4, 2), 16)
        , color = new nodes.RGBA(r, g, b, 1);
                    color.raw = captures[0];
                    return new Token('color', color);
                }
            },

            /**
            * #rrggbbaa
            */

            rrggbbaa: function () {
                var captures;
                if (captures = /^#([a-fA-F0-9]{8})[ \t]*/.exec(this.str)) {
                    this.skip(captures);
                    var rgb = captures[1]
        , r = parseInt(rgb.substr(0, 2), 16)
        , g = parseInt(rgb.substr(2, 2), 16)
        , b = parseInt(rgb.substr(4, 2), 16)
        , a = parseInt(rgb.substr(6, 2), 16)
        , color = new nodes.RGBA(r, g, b, a / 255);
                    color.raw = captures[0];
                    return new Token('color', color);
                }
            },

            /**
            * [^\n,;]+
            */

            selector: function () {
                var captures;
                if (captures = /^[^{\n,]+/.exec(this.str)) {
                    var selector = captures[0];
                    this.skip(captures);
                    return new Token('selector', selector);
                }
            }
        };
    }); // module: lexer.js


    require.register("nodes/arguments.js", function (module, exports, require) {


        /*!
        * Stylus - Arguments
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('../nodes')
  , utils = require('../utils');

        /**
        * Initialize a new `Arguments`.
        *
        * @api public
        */

        var Arguments = module.exports = function Arguments() {
            nodes.Expression.call(this);
            this.map = {};
        };

        /**
        * Inherit from `nodes.Expression.prototype`.
        */

        Arguments.prototype.__proto__ = nodes.Expression.prototype;

        /**
        * Initialize an `Arguments` object with the nodes
        * from the given `expr`.
        *
        * @param {Expression} expr
        * @return {Arguments}
        * @api public
        */

        Arguments.fromExpression = function (expr) {
            var args = new Arguments
    , len = expr.nodes.length;
            args.lineno = expr.lineno;
            args.isList = expr.isList;
            for (var i = 0; i < len; ++i) {
                args.push(expr.nodes[i]);
            }
            return args;
        };

        /**
        * Return a clone of this node.
        *
        * @return {Node}
        * @api public
        */

        Arguments.prototype.clone = function () {
            var clone = nodes.Expression.prototype.clone.call(this);
            clone.map = this.map;
            return clone;
        };

    }); // module: nodes/arguments.js


    require.register("nodes/binop.js", function (module, exports, require) {


        /*!
        * Stylus - BinOp
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `BinOp` with `op`, `left` and `right`.
        *
        * @param {String} op
        * @param {Node} left
        * @param {Node} right
        * @api public
        */

        var BinOp = module.exports = function BinOp(op, left, right) {
            Node.call(this);
            this.op = op;
            this.left = left;
            this.right = right;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        BinOp.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        BinOp.prototype.clone = function () {
            var clone = new BinOp(
      this.op
    , this.left.clone()
    , this.right ?
      this.right.clone()
      : null);
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            if (this.val) clone.val = this.val.clone();
            return clone;
        };
    }); // module: nodes/binop.js


    require.register("nodes/block.js", function (module, exports, require) {


        /*!
        * Stylus - Block
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Block` node with `parent` Block.
        *
        * @param {Block} parent
        * @api public
        */

        var Block = module.exports = function Block(parent, node) {
            Node.call(this);
            this.nodes = [];
            this.parent = parent;
            this.node = node;
            this.scope = true;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Block.prototype.__proto__ = Node.prototype;

        /**
        * Check if this block has properties..
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Block.prototype, 'hasProperties', { configurable: true,
            get: function () {
                for (var i = 0, len = this.nodes.length; i < len; ++i) {
                    if ('property' == this.nodes[i].nodeName) {
                        return true;
                    }
                }
            } 
        });

        /**
        * Check if this block is empty.
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Block.prototype, 'isEmpty', { configurable: true,
            get: function () {
                return !this.nodes.length;
            } 
        });

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Block.prototype.clone = function () {
            var clone = new Block(this.parent, this.node);
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            clone.scope = this.scope;
            this.nodes.forEach(function (node) {
                node = node.clone();
                switch (node.nodeName) {
                    case 'each':
                    case 'group':
                        node.block.parent = clone;
                        break;
                    case 'ident':
                        if ('function' == node.val.nodeName) {
                            node.val.block.parent = clone;
                        }
                }
                clone.push(node);
            });
            return clone;
        };

        /**
        * Push a `node` to this block.
        *
        * @param {Node} node
        * @api public
        */

        Block.prototype.push = function (node) {
            this.nodes.push(node);
        };
    }); // module: nodes/block.js


    require.register("nodes/boolean.js", function (module, exports, require) {


        /*!
        * Stylus - Boolean
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Boolean` node with the given `val`.
        *
        * @param {Boolean} val
        * @api public
        */

        var Boolean = module.exports = function Boolean(val) {
            Node.call(this);
            if (this.nodeName) {
                this.val = !!val;
            } else {
                return new Boolean(val);
            }
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Boolean.prototype.__proto__ = Node.prototype;

        /**
        * Return `this` node.
        *
        * @return {Boolean}
        * @api public
        */

        Boolean.prototype.toBoolean = function () {
            return this;
        };

        /**
        * Return `true` if this node represents `true`.
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Boolean.prototype, 'isTrue', { configurable: true,
            get: function () {
                return this.val;
            } 
        });

        /**
        * Return `true` if this node represents `false`.
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Boolean.prototype, 'isFalse', { configurable: true,
            get: function () {
                return !this.val;
            } 
        });

        /**
        * Negate the value.
        *
        * @return {Boolean}
        * @api public
        */

        Boolean.prototype.negate = function () {
            return new Boolean(!this.val);
        };

        /**
        * Return 'Boolean'.
        *
        * @return {String}
        * @api public
        */

        Boolean.prototype.inspect = function () {
            return '[Boolean ' + this.val + ']';
        };

        /**
        * Return 'true' or 'false'.
        *
        * @return {String}
        * @api public
        */

        Boolean.prototype.toString = function () {
            return this.val
    ? 'true'
    : 'false';
        };
    }); // module: nodes/boolean.js


    require.register("nodes/call.js", function (module, exports, require) {


        /*!
        * Stylus - Call
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Call` with `name` and `args`.
        *
        * @param {String} name
        * @param {Expression} args
        * @api public
        */

        var Call = module.exports = function Call(name, args) {
            Node.call(this);
            this.name = name;
            this.args = args;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Call.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Call.prototype.clone = function () {
            var clone = new Call(this.name, this.args.clone());
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };

        /**
        * Return <name>().
        *
        * @return {String}
        * @api public
        */

        Call.prototype.toString = function () {
            return this.name + '()';
        };
    }); // module: nodes/call.js


    require.register("nodes/charset.js", function (module, exports, require) {


        /*!
        * Stylus - Charset
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Charset` with the given `val`
        *
        * @param {String} val
        * @api public
        */

        var Charset = module.exports = function Charset(val) {
            Node.call(this);
            this.val = val;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Charset.prototype.__proto__ = Node.prototype;

        /**
        * Return @charset "val".
        *
        * @return {String}
        * @api public
        */

        Charset.prototype.toString = function () {
            return '@charset ' + this.val;
        };
    }); // module: nodes/charset.js


    require.register("nodes/comment.js", function (module, exports, require) {


        /*!
        * Stylus - Comment
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Comment` with the given `str`.
        *
        * @param {String} str
        * @param {Boolean} suppress
        * @api public
        */

        var Comment = module.exports = function Comment(str, suppress) {
            Node.call(this);
            this.str = str;
            this.suppress = suppress;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Comment.prototype.__proto__ = Node.prototype;
    }); // module: nodes/comment.js


    require.register("nodes/each.js", function (module, exports, require) {


        /*!
        * Stylus - Each
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Each` node with the given `val` name,
        * `key` name, `expr`, and `block`.
        *
        * @param {String} val
        * @param {String} key
        * @param {Expression} expr
        * @param {Block} block
        * @api public
        */

        var Each = module.exports = function Each(val, key, expr, block) {
            Node.call(this);
            this.val = val;
            this.key = key;
            this.expr = expr;
            this.block = block;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Each.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Each.prototype.clone = function () {
            var clone = new Each(
      this.val
    , this.key
    , this.expr.clone()
    , this.block.clone());
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };
    }); // module: nodes/each.js


    require.register("nodes/expression.js", function (module, exports, require) {


        /*!
        * Stylus - Expression
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('../nodes')
  , utils = require('../utils');

        /**
        * Initialize a new `Expression`.
        *
        * @param {Boolean} isList
        * @api public
        */

        var Expression = module.exports = function Expression(isList) {
            Node.call(this);
            this.nodes = [];
            this.isList = isList;
        };

        /**
        * Check if the variable has a value.
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Expression.prototype, 'isEmpty', { configurable: true,
            get: function () {
                return !this.nodes.length;
            } 
        });

        /**
        * Return the first node in this expression.
        *
        * @return {Node}
        * @api public
        */

        Object.defineProperty(Expression.prototype, 'first', { configurable: true,
            get: function () {
                return this.nodes[0]
    ? this.nodes[0].first
    : nodes['null'];
            } 
        });

        /**
        * Hash all the nodes in order.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(Expression.prototype, 'hash', { configurable: true,
            get: function () {
                return this.nodes.map(function (node) {
                    return node.hash;
                }).join('::');
            } 
        });

        /**
        * Inherit from `Node.prototype`.
        */

        Expression.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Expression.prototype.clone = function () {
            var clone = new this.constructor(this.isList);
            clone.preserve = this.preserve;
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            for (var i = 0; i < this.nodes.length; ++i) {
                clone.push(this.nodes[i].clone());
            }
            return clone;
        };

        /**
        * Push the given `node`.
        *
        * @param {Node} node
        * @api public
        */

        Expression.prototype.push = function (node) {
            this.nodes.push(node);
        };

        /**
        * Operate on `right` with the given `op`.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        Expression.prototype.operate = function (op, right, val) {
            switch (op) {
                case '[]=':
                    var self = this
        , range = utils.unwrap(right).nodes
        , val = utils.unwrap(val)
        , len;
                    range.forEach(function (unit) {
                        len = self.nodes.length;
                        if ('unit' == unit.nodeName) {
                            var i = unit.val;
                            while (i-- > len) self.nodes[i] = nodes['null'];
                            self.nodes[unit.val] = val;
                        }
                    });
                    return val;
                case '[]':
                    var expr = new nodes.Expression
        , vals = utils.unwrap(this).nodes
        , range = utils.unwrap(right).nodes;
                    range.forEach(function (unit) {
                        if ('unit' == unit.nodeName) {
                            var node = vals[unit.val];
                            if (node) expr.push(node);
                        }
                    });
                    return expr.isEmpty
        ? nodes['null']
        : utils.unwrap(expr);
                case '||':
                    return this.toBoolean().isTrue
        ? this
        : right;
                case 'in':
                    return Node.prototype.operate.call(this, op, right);
                case '!=':
                    return this.operate('==', right, val).negate();
                case '==':
                    var len = this.nodes.length
        , right = right.toExpression()
        , a
        , b;
                    if (len != right.nodes.length) return nodes['false'];
                    for (var i = 0; i < len; ++i) {
                        a = this.nodes[i];
                        b = right.nodes[i];
                        if (a.operate(op, b).isTrue) continue;
                        return nodes['false'];
                    }
                    return nodes['true'];
                    break;
                default:
                    return this.first.operate(op, right, val);
            }
        };

        /**
        * Expressions with length > 1 are truthy,
        * otherwise the first value's toBoolean()
        * method is invoked.
        *
        * @return {Boolean}
        * @api public
        */

        Expression.prototype.toBoolean = function () {
            if (this.nodes.length > 1) return nodes['true'];
            return this.first.toBoolean();
        };

        /**
        * Return "<a> <b> <c>" or "<a>, <b>, <c>" if
        * the expression represents a list.
        *
        * @return {String}
        * @api public
        */

        Expression.prototype.toString = function () {
            return '(' + this.nodes.map(function (node) {
                return node.toString();
            }).join(this.isList ? ', ' : ' ') + ')';
        };

    }); // module: nodes/expression.js


    require.register("nodes/fontface.js", function (module, exports, require) {


        /*!
        * Stylus - FontFace
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `FontFace` with the given `block`.
        *
        * @param {Block} block
        * @api public
        */

        var FontFace = module.exports = function FontFace(block) {
            Node.call(this);
            this.block = block;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        FontFace.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        FontFace.prototype.clone = function () {
            var clone = new FontFace(this.block.clone());
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };

        /**
        * Return `@oage name`.
        *
        * @return {String}
        * @api public
        */

        FontFace.prototype.toString = function () {
            return '@font-face';
        };
    }); // module: nodes/fontface.js


    require.register("nodes/function.js", function (module, exports, require) {


        /*!
        * Stylus - Function
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Function` with `name`, `params`, and `body`.
        *
        * @param {String} name
        * @param {Params|Function} params
        * @param {Block} body
        * @api public
        */

        var Function = module.exports = function Function(name, params, body) {
            Node.call(this);
            this.name = name;
            this.params = params;
            this.block = body;
            if ('function' == typeof params) this.fn = params;
        };

        /**
        * Check function arity.
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Function.prototype, 'arity', { configurable: true,
            get: function () {
                return this.params.length;
            } 
        });

        /**
        * Inherit from `Node.prototype`.
        */

        Function.prototype.__proto__ = Node.prototype;

        /**
        * Return hash.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(Function.prototype, 'hash', { configurable: true,
            get: function () {
                return 'function ' + this.name;
            } 
        });

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Function.prototype.clone = function () {
            if (this.fn) {
                var clone = new Function(
        this.name
      , this.fn);
            } else {
                var clone = new Function(
        this.name
      , this.params.clone()
      , this.block.clone());
            }
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };

        /**
        * Return <name>(param1, param2, ...).
        *
        * @return {String}
        * @api public
        */

        Function.prototype.toString = function () {
            if (this.fn) {
                return this.name
      + '('
      + this.fn.toString()
        .match(/^function *\((.*?)\)/)
        .slice(1)
        .join(', ')
      + ')';
            } else {
                return this.name
      + '('
      + this.params.nodes.join(', ')
      + ')';
            }
        };
    }); // module: nodes/function.js


    require.register("nodes/group.js", function (module, exports, require) {


        /*!
        * Stylus - Group
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Group`.
        *
        * @api public
        */

        var Group = module.exports = function Group() {
            Node.call(this);
            this.nodes = [];
            this['extends'] = [];
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Group.prototype.__proto__ = Node.prototype;

        /**
        * Push the given `selector` node.
        *
        * @param {Selector} selector
        * @api public
        */

        Group.prototype.push = function (selector) {
            this.nodes.push(selector);
        };

        /**
        * Return this set's `Block`.
        */

        Object.defineProperty(Group.prototype, 'block', {
            get: function () {
                return this.nodes[0].block;
            },
            set: function (blk) {
                for (var i = 0, len = this.nodes.length; i < len; ++i) {
                    this.nodes[i].block = blk;
                }
            },
            configurable: true,
            enumerable: true
        });

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Group.prototype.clone = function () {
            var clone = new Group;
            clone.lineno = this.lineno;
            this.nodes.forEach(function (node) {
                clone.push(node.clone());
            });
            clone.filename = this.filename;
            clone.block = this.block.clone();
            return clone;
        };
    }); // module: nodes/group.js


    require.register("nodes/hsla.js", function (module, exports, require) {


        /*!
        * Stylus - HSLA
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `HSLA` with the given h,s,l,a component values.
        *
        * @param {Number} h
        * @param {Number} s
        * @param {Number} l
        * @param {Number} a
        * @api public
        */

        var HSLA = exports = module.exports = function HSLA(h, s, l, a) {
            Node.call(this);
            this.h = clampDegrees(h);
            this.s = clampPercentage(s);
            this.l = clampPercentage(l);
            this.a = clampAlpha(a);
            this.hsla = this;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        HSLA.prototype.__proto__ = Node.prototype;

        /**
        * Return hsla(n,n,n,n).
        *
        * @return {String}
        * @api public
        */

        HSLA.prototype.toString = function () {
            return 'hsla('
    + this.h + ','
    + this.s.toFixed(0) + ','
    + this.l.toFixed(0) + ','
    + this.a + ')';
        };

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        HSLA.prototype.clone = function () {
            var clone = new HSLA(
      this.h
    , this.s
    , this.l
    , this.a);
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };

        /**
        * Return rgba `RGBA` representation.
        *
        * @return {RGBA}
        * @api public
        */

        Object.defineProperty(HSLA.prototype, 'rgba', { configurable: true,
            get: function () {
                return nodes.RGBA.fromHSLA(this);
            } 
        });

        /**
        * Return hash.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(HSLA.prototype, 'hash', { configurable: true,
            get: function () {
                return this.rgba.toString();
            } 
        });

        /**
        * Add h,s,l to the current component values.
        *
        * @param {Number} h
        * @param {Number} s
        * @param {Number} l
        * @return {HSLA} new node
        * @api public
        */

        HSLA.prototype.add = function (h, s, l) {
            return new HSLA(
      this.h + h
    , this.s + s
    , this.l + l
    , this.a);
        };

        /**
        * Subtract h,s,l from the current component values.
        *
        * @param {Number} h
        * @param {Number} s
        * @param {Number} l
        * @return {HSLA} new node
        * @api public
        */

        HSLA.prototype.sub = function (h, s, l) {
            return this.add(-h, -s, -l);
        };

        /**
        * Operate on `right` with the given `op`.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        HSLA.prototype.operate = function (op, right) {
            switch (op) {
                case '==':
                case '!=':
                case '<=':
                case '>=':
                case '<':
                case '>':
                case 'is a':
                case '||':
                case '&&':
                    return this.rgba.operate(op, right);
                default:
                    return this.rgba.operate(op, right).hsla;
            }
        };

        /**
        * Return `HSLA` representation of the given `color`.
        *
        * @param {RGBA} color
        * @return {HSLA}
        * @api public
        */

        exports.fromRGBA = function (rgba) {
            var r = rgba.r / 255
    , g = rgba.g / 255
    , b = rgba.b / 255
    , a = rgba.a;

            var min = Math.min(r, g, b)
    , max = Math.max(r, g, b)
    , l = (max + min) / 2
    , d = max - min
    , h, s;

            switch (max) {
                case min: h = 0; break;
                case r: h = 60 * (g - b) / d; break;
                case g: h = 60 * (b - r) / d + 120; break;
                case b: h = 60 * (r - g) / d + 240; break;
            }

            if (max == min) {
                s = 0;
            } else if (l < .5) {
                s = d / (2 * l);
            } else {
                s = d / (2 - 2 * l);
            }

            h %= 360;
            s *= 100;
            l *= 100;

            return new HSLA(h, s, l, a);
        };

        /**
        * Adjust lightness by `percent`.
        *
        * @param {Number} percent
        * @return {HSLA} for chaining
        * @api public
        */

        HSLA.prototype.adjustLightness = function (percent) {
            this.l = clampPercentage(this.l + this.l * (percent / 100));
            return this;
        };

        /**
        * Adjust hue by `deg`.
        *
        * @param {Number} deg
        * @return {HSLA} for chaining
        * @api public
        */

        HSLA.prototype.adjustHue = function (deg) {
            this.h = clampDegrees(this.h + deg);
            return this;
        };

        /**
        * Clamp degree `n` >= 0 and <= 360.
        *
        * @param {Number} n
        * @return {Number}
        * @api private
        */

        function clampDegrees(n) {
            n = n % 360;
            return n >= 0 ? n : 360 + n;
        }

        /**
        * Clamp percentage `n` >= 0 and <= 100.
        *
        * @param {Number} n
        * @return {Number}
        * @api private
        */

        function clampPercentage(n) {
            return Math.max(0, Math.min(n, 100));
        }

        /**
        * Clamp alpha `n` >= 0 and <= 1.
        *
        * @param {Number} n
        * @return {Number}
        * @api private
        */

        function clampAlpha(n) {
            return Math.max(0, Math.min(n, 1));
        }
    }); // module: nodes/hsla.js


    require.register("nodes/ident.js", function (module, exports, require) {


        /*!
        * Stylus - Ident
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Ident` by `name` with the given `val` node.
        *
        * @param {String} name
        * @param {Node} val
        * @api public
        */

        var Ident = module.exports = function Ident(name, val) {
            Node.call(this);
            this.name = name;
            this.string = name;
            this.val = val || nodes['null'];
        };

        /**
        * Check if the variable has a value.
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Ident.prototype, 'isEmpty', { configurable: true,
            get: function () {
                return undefined == this.val;
            } 
        });

        /**
        * Return hash.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(Ident.prototype, 'hash', { configurable: true,
            get: function () {
                return this.name;
            } 
        });

        /**
        * Inherit from `Node.prototype`.
        */

        Ident.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Ident.prototype.clone = function () {
            var clone = new Ident(this.name, this.val.clone());
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            clone.property = this.property;
            return clone;
        };

        /**
        * Return <name>.
        *
        * @return {String}
        * @api public
        */

        Ident.prototype.toString = function () {
            return this.name;
        };

        /**
        * Coerce `other` to an ident.
        *
        * @param {Node} other
        * @return {String}
        * @api public
        */

        Ident.prototype.coerce = function (other) {
            switch (other.nodeName) {
                case 'ident':
                case 'string':
                case 'literal':
                    return new Ident(other.string);
                default:
                    return Node.prototype.coerce.call(this, other);
            }
        };

        /**
        * Operate on `right` with the given `op`.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        Ident.prototype.operate = function (op, right) {
            var val = right.first;
            switch (op) {
                case '-':
                    if ('unit' == val.nodeName) {
                        var expr = new nodes.Expression;
                        val.val = -val.val;
                        expr.push(this);
                        expr.push(val);
                        return expr;
                    }
                case '+':
                    return new nodes.Ident(this.string + this.coerce(val).string);
            }
            return Node.prototype.operate.call(this, op, right);
        };
    }); // module: nodes/ident.js


    require.register("nodes/if.js", function (module, exports, require) {


        /*!
        * Stylus - If
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `If` with the given `cond`.
        *
        * @param {Expression} cond
        * @param {Boolean|Block} negate, block
        * @api public
        */

        var If = module.exports = function If(cond, negate) {
            Node.call(this);
            this.cond = cond;
            this.elses = [];
            if (negate && negate.nodeName) {
                this.block = negate;
            } else {
                this.negate = negate;
            }
        };

        /**
        * Inherit from `Node.prototype`.
        */

        If.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        If.prototype.clone = function () {
            var cond = this.cond.clone()
    , block = this.block.clone();
            var clone = new If(cond, block);
            clone.elses = this.elses.map(function (node) { return node.clone(); });
            clone.negate = this.negate;
            clone.postfix = this.postfix;
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };
    }); // module: nodes/if.js


    require.register("nodes/import.js", function (module, exports, require) {


        /*!
        * Stylus - Import
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Import` with the given `expr`.
        *
        * @param {Expression} expr
        * @api public
        */

        var Import = module.exports = function Import(expr) {
            Node.call(this);
            this.path = expr;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Import.prototype.__proto__ = Node.prototype;
    }); // module: nodes/import.js


    require.register("nodes/index.js", function (module, exports, require) {


        /*!
        * Stylus - nodes
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Constructors
        */

        exports.Node = require('./node');
        exports.Root = require('./root');
        exports.Null = require('./null');
        exports.Each = require('./each');
        exports.If = require('./if');
        exports.Call = require('./call');
        exports.Page = require('./page');
        exports.FontFace = require('./fontface');
        exports.UnaryOp = require('./unaryop');
        exports.BinOp = require('./binop');
        exports.Ternary = require('./ternary');
        exports.Block = require('./block');
        exports.Unit = require('./unit');
        exports.String = require('./string');
        exports.HSLA = require('./hsla');
        exports.RGBA = require('./rgba');
        exports.Ident = require('./ident');
        exports.Group = require('./group');
        exports.Literal = require('./literal');
        exports.JSLiteral = require('./jsliteral');
        exports['Boolean'] = require('./boolean');
        exports.Return = require('./return');
        exports.Media = require('./media');
        exports.Params = require('./params');
        exports.Comment = require('./comment');
        exports.Keyframes = require('./keyframes');
        exports.Charset = require('./charset');
        exports.Import = require('./import');
        exports['Extend'] = require('./extend');
        exports['Function'] = require('./function');
        exports.Property = require('./property');
        exports.Selector = require('./selector');
        exports.Expression = require('./expression');
        exports.Arguments = require('./arguments');

        /**
        * Singletons.
        */

        exports['true'] = new exports['Boolean'](true);
        exports['false'] = new exports['Boolean'](false);
        exports['null'] = new exports.Null;
    }); // module: nodes/index.js


    require.register("nodes/jsliteral.js", function (module, exports, require) {


        /*!
        * Stylus - JSLiteral
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `JSLiteral` with the given `str`.
        *
        * @param {String} str
        * @api public
        */

        var JSLiteral = module.exports = function JSLiteral(str) {
            Node.call(this);
            this.val = str;
            this.string = str;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        JSLiteral.prototype.__proto__ = Node.prototype;
    }); // module: nodes/jsliteral.js


    require.register("nodes/keyframes.js", function (module, exports, require) {


        /*!
        * Stylus - Keyframes
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Keyframes` with the given `name`,
        * and optional vendor `prefix`.
        *
        * @param {String} name
        * @param {String} prefix
        * @api public
        */

        var Keyframes = module.exports = function Keyframes(name, prefix) {
            Node.call(this);
            this.name = name;
            this.frames = [];
            this.prefix = prefix || 'official';
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Keyframes.prototype.__proto__ = Node.prototype;

        /**
        * Push the given `block` at `pos`.
        *
        * @param {Array} pos
        * @param {Block} block
        * @api public
        */

        Keyframes.prototype.push = function (pos, block) {
            this.frames.push({
                pos: pos
    , block: block
            });
        };

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Keyframes.prototype.clone = function () {
            var clone = new Keyframes(this.name);
            clone.lineno = this.lineno;
            clone.prefix = this.prefix;
            clone.frames = this.frames.map(function (node) {
                node.block = node.block.clone();
                return node;
            });
            return clone;
        };

        /**
        * Return `@keyframes name`.
        *
        * @return {String}
        * @api public
        */

        Keyframes.prototype.toString = function () {
            return '@keyframes ' + this.name;
        };
    }); // module: nodes/keyframes.js


    require.register("nodes/literal.js", function (module, exports, require) {


        /*!
        * Stylus - Literal
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Literal` with the given `str`.
        *
        * @param {String} str
        * @api public
        */

        var Literal = module.exports = function Literal(str) {
            Node.call(this);
            this.val = str;
            this.string = str;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Literal.prototype.__proto__ = Node.prototype;

        /**
        * Return hash.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(Literal.prototype, 'hash', { configurable: true,
            get: function () {
                return this.val;
            } 
        });

        /**
        * Return literal value.
        *
        * @return {String}
        * @api public
        */

        Literal.prototype.toString = function () {
            return this.val;
        };

        /**
        * Coerce `other` to a literal.
        *
        * @param {Node} other
        * @return {String}
        * @api public
        */

        Literal.prototype.coerce = function (other) {
            switch (other.nodeName) {
                case 'ident':
                case 'string':
                case 'literal':
                    return new Literal(other.string);
                default:
                    return Node.prototype.coerce.call(this, other);
            }
        };

        /**
        * Operate on `right` with the given `op`.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        Literal.prototype.operate = function (op, right) {
            var val = right.first;
            switch (op) {
                case '+':
                    return new nodes.Literal(this.string + this.coerce(val).string);
                default:
                    return Node.prototype.operate.call(this, op, right);
            }
        };
    }); // module: nodes/literal.js


    require.register("nodes/media.js", function (module, exports, require) {


        /*!
        * Stylus - Media
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Media` with the given `val`
        *
        * @param {String} val
        * @api public
        */

        var Media = module.exports = function Media(val) {
            Node.call(this);
            this.val = val;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Media.prototype.__proto__ = Node.prototype;

        /**
        * Return @media "val".
        *
        * @return {String}
        * @api public
        */

        Media.prototype.toString = function () {
            return '@media ' + this.val;
        };
    }); // module: nodes/media.js


    require.register("nodes/node.js", function (module, exports, require) {


        /*!
        * Stylus - Node
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Evaluator = require('../visitor/evaluator')
  , utils = require('../utils')
  , nodes = require('./');

        /**
        * Node constructor.
        *
        * @api public
        */

        var Node = module.exports = function Node() {
            this.lineno = nodes.lineno;
            Object.defineProperty(this, 'filename', { writable: true, value: nodes.filename });
        };

        /**
        * Return this node.
        *
        * @return {Node}
        * @api public
        */

        Object.defineProperty(Node.prototype, 'first', { configurable: true,
            get: function () {
                return this;
            } 
        });

        /**
        * Return hash.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(Node.prototype, 'hash', { configurable: true,
            get: function () {
                return this.val;
            } 
        });

        /**
        * Return node name.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(Node.prototype, 'nodeName', { configurable: true,
            get: function () {
                return this.constructor.name.toLowerCase();
            } 
        });

        /**
        * Return this node.
        * 
        * @return {Node}
        * @api public
        */

        Node.prototype.clone = function () {
            return this;
        };

        /**
        * Nodes by default evaluate to themselves.
        *
        * @return {Node}
        * @api public
        */

        Node.prototype.eval = function () {
            return new Evaluator(this).evaluate();
        };

        /**
        * Return true.
        *
        * @return {Boolean}
        * @api public
        */

        Node.prototype.toBoolean = function () {
            return nodes['true'];
        };

        /**
        * Return the expression, or wrap this node in an expression.
        *
        * @return {Expression}
        * @api public
        */

        Node.prototype.toExpression = function () {
            if ('expression' == this.nodeName) return this;
            var expr = new nodes.Expression;
            expr.push(this);
            return expr;
        };

        /**
        * Return false if `op` is generally not coerced.
        *
        * @param {String} op
        * @return {Boolean}
        * @api private
        */

        Node.prototype.shouldCoerce = function (op) {
            switch (op) {
                case 'is a':
                case 'in':
                case '||':
                case '&&':
                    return false;
                default:
                    return true;
            }
        };

        /**
        * Operate on `right` with the given `op`.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        Node.prototype.operate = function (op, right) {
            switch (op) {
                case 'is a':
                    if ('string' == right.nodeName) {
                        return nodes.Boolean(this.nodeName == right.val);
                    } else {
                        throw new Error('"is a" expects a string, got ' + right.toString());
                    }
                case '==':
                    return nodes.Boolean(this.hash == right.hash);
                case '!=':
                    return nodes.Boolean(this.hash != right.hash);
                case '>=':
                    return nodes.Boolean(this.hash >= right.hash);
                case '<=':
                    return nodes.Boolean(this.hash <= right.hash);
                case '>':
                    return nodes.Boolean(this.hash > right.hash);
                case '<':
                    return nodes.Boolean(this.hash < right.hash);
                case '||':
                    return this.toBoolean().isTrue
        ? this
        : right;
                case 'in':
                    var vals = utils.unwrap(right).nodes
        , hash = this.hash;
                    if (!vals) throw new Error('"in" given invalid right-hand operand, expecting an expression');
                    for (var i = 0, len = vals.length; i < len; ++i) {
                        if (hash == vals[i].hash) {
                            return nodes['true'];
                        }
                    }
                    return nodes['false'];
                case '&&':
                    var a = this.toBoolean()
        , b = right.toBoolean();
                    return a.isTrue && b.isTrue
        ? right
        : a.isFalse
          ? this
          : right;
                default:
                    if ('[]' == op) {
                        var msg = 'cannot perform '
          + this
          + '[' + right + ']';
                    } else {
                        var msg = 'cannot perform'
          + ' ' + this
          + ' ' + op
          + ' ' + right;
                    }
                    throw new Error(msg);
            }
        };

        /**
        * Initialize a new `CoercionError` with the given `msg`.
        *
        * @param {String} msg
        * @api private
        */

        function CoercionError(msg) {
            this.name = 'CoercionError'
            this.message = msg
            Error.captureStackTrace(this, CoercionError);
        }

        /**
        * Inherit from `Error.prototype`.
        */

        CoercionError.prototype.__proto__ = Error.prototype;

        /**
        * Default coercion throws.
        *
        * @param {Node} other
        * @return {Node}
        * @api public
        */

        Node.prototype.coerce = function (other) {
            if (other.nodeName == this.nodeName) return other;
            throw new CoercionError('cannot coerce ' + other + ' to ' + this.nodeName);
        };
    }); // module: nodes/node.js


    require.register("nodes/null.js", function (module, exports, require) {


        /*!
        * Stylus - Null
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Null` node.
        *
        * @api public
        */

        var Null = module.exports = function Null() { };

        /**
        * Inherit from `Node.prototype`.
        */

        Null.prototype.__proto__ = Node.prototype;

        /**
        * Return 'Null'.
        *
        * @return {String}
        * @api public
        */

        Null.prototype.inspect =
Null.prototype.toString = function () {
    return 'null';
};

        /**
        * Return false.
        *
        * @return {Boolean}
        * @api public
        */

        Null.prototype.toBoolean = function () {
            return nodes['false'];
        };

        /**
        * Check if the node is a null node.
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Null.prototype, 'isNull', { configurable: true,
            get: function () {
                return true;
            } 
        });

        /**
        * Return hash.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(Null.prototype, 'hash', { configurable: true,
            get: function () {
                return null;
            } 
        });
    }); // module: nodes/null.js


    require.register("nodes/page.js", function (module, exports, require) {


        /*!
        * Stylus - Page
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Page` with the given `selector` and `block`.
        *
        * @param {Selector} selector
        * @param {Block} block
        * @api public
        */

        var Page = module.exports = function Page(selector, block) {
            Node.call(this);
            this.selector = selector;
            this.block = block;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Page.prototype.__proto__ = Node.prototype;

        /**
        * Return `@page name`.
        *
        * @return {String}
        * @api public
        */

        Page.prototype.toString = function () {
            return '@page ' + this.selector;
        };
    }); // module: nodes/page.js


    require.register("nodes/params.js", function (module, exports, require) {


        /*!
        * Stylus - Params
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Params` with `name`, `params`, and `body`.
        *
        * @param {String} name
        * @param {Params} params
        * @param {Expression} body
        * @api public
        */

        var Params = module.exports = function Params() {
            Node.call(this);
            this.nodes = [];
        };

        /**
        * Check function arity.
        *
        * @return {Boolean}
        * @api public
        */

        Object.defineProperty(Params.prototype, 'length', { configurable: true,
            get: function () {
                return this.nodes.length;
            } 
        });

        /**
        * Inherit from `Node.prototype`.
        */

        Params.prototype.__proto__ = Node.prototype;

        /**
        * Push the given `node`.
        *
        * @param {Node} node
        * @api public
        */

        Params.prototype.push = function (node) {
            this.nodes.push(node);
        };

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Params.prototype.clone = function () {
            var clone = new Params;
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            this.nodes.forEach(function (node) {
                clone.push(node.clone());
            });
            return clone;
        };

    }); // module: nodes/params.js


    require.register("nodes/property.js", function (module, exports, require) {


        /*!
        * Stylus - Property
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Property` with the given `segs` and optional `expr`.
        *
        * @param {Array} segs
        * @param {Expression} expr
        * @api public
        */

        var Property = module.exports = function Property(segs, expr) {
            Node.call(this);
            this.segments = segs;
            this.expr = expr;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Property.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Property.prototype.clone = function () {
            var clone = new Property(this.segments);
            clone.name = this.name;
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            clone.segments = this.segments.map(function (node) { return node.clone(); });
            if (this.expr) clone.expr = this.expr.clone();
            return clone;
        };

        /**
        * Return string representation of this node.
        *
        * @return {String}
        * @api public
        */

        Property.prototype.toString = function () {
            return 'property(' + this.segments.join('') + ', ' + this.expr + ')';
        };

        /**
        * Operate on the property expression.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        Property.prototype.operate = function (op, right, val) {
            return this.expr.operate(op, right, val);
        };
    }); // module: nodes/property.js


    require.register("nodes/return.js", function (module, exports, require) {


        /*!
        * Stylus - Return
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Return` node with the given `expr`.
        *
        * @param {Expression} expr
        * @api public
        */

        var Return = module.exports = function Return(expr) {
            this.expr = expr || nodes['null'];
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Return.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Return.prototype.clone = function () {
            var clone = new Return(this.expr.clone());
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };
    }); // module: nodes/return.js


    require.register("nodes/rgba.js", function (module, exports, require) {


        /*!
        * Stylus - RGBA
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , HSLA = require('./hsla')
  , functions = require('../functions')
  , adjust = functions['-adjust']
  , nodes = require('./');

        /**
        * Initialize a new `RGBA` with the given r,g,b,a component values.
        *
        * @param {Number} r
        * @param {Number} g
        * @param {Number} b
        * @param {Number} a
        * @api public
        */

        var RGBA = exports = module.exports = function RGBA(r, g, b, a) {
            Node.call(this);
            this.r = clamp(r);
            this.g = clamp(g);
            this.b = clamp(b);
            this.a = clampAlpha(a);
            this.rgba = this;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        RGBA.prototype.__proto__ = Node.prototype;

        /**
        * Return an `RGBA` without clamping values.
        * 
        * @param {Number} r
        * @param {Number} g
        * @param {Number} b
        * @param {Number} a
        * @return {RGBA}
        * @api public
        */

        RGBA.withoutClamping = function (r, g, b, a) {
            var rgba = new RGBA(0, 0, 0, 0);
            rgba.r = r;
            rgba.g = g;
            rgba.b = b;
            rgba.a = a;
            return rgba;
        };

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        RGBA.prototype.clone = function () {
            var clone = new RGBA(
      this.r
    , this.g
    , this.b
    , this.a);
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };

        /**
        * Return true.
        *
        * @return {Boolean}
        * @api public
        */

        RGBA.prototype.toBoolean = function () {
            return nodes['true'];
        };

        /**
        * Return `HSLA` representation.
        *
        * @return {HSLA}
        * @api public
        */

        Object.defineProperty(RGBA.prototype, 'hsla', { configurable: true,
            get: function () {
                return HSLA.fromRGBA(this);
            } 
        });

        /**
        * Return hash.
        *
        * @return {String}
        * @api public
        */

        Object.defineProperty(RGBA.prototype, 'hash', { configurable: true,
            get: function () {
                return this.toString();
            } 
        });

        /**
        * Add r,g,b,a to the current component values.
        *
        * @param {Number} r
        * @param {Number} g
        * @param {Number} b
        * @param {Number} a
        * @return {RGBA} new node
        * @api public
        */

        RGBA.prototype.add = function (r, g, b, a) {
            return new RGBA(
      this.r + r
    , this.g + g
    , this.b + b
    , this.a + a);
        };

        /**
        * Subtract r,g,b,a from the current component values.
        *
        * @param {Number} r
        * @param {Number} g
        * @param {Number} b
        * @param {Number} a
        * @return {RGBA} new node
        * @api public
        */

        RGBA.prototype.sub = function (r, g, b, a) {
            return new RGBA(
      this.r - r
    , this.g - g
    , this.b - b
    , a == 1 ? this.a : this.a - a);
        };

        /**
        * Multiply rgb components by `n`.
        *
        * @param {String} n
        * @return {RGBA} new node
        * @api public
        */

        RGBA.prototype.multiply = function (n) {
            return new RGBA(
      this.r * n
    , this.g * n
    , this.b * n
    , this.a);
        };

        /**
        * Divide rgb components by `n`.
        *
        * @param {String} n
        * @return {RGBA} new node
        * @api public
        */

        RGBA.prototype.divide = function (n) {
            return new RGBA(
      this.r / n
    , this.g / n
    , this.b / n
    , this.a);
        };

        /**
        * Operate on `right` with the given `op`.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        RGBA.prototype.operate = function (op, right) {
            right = right.first;

            switch (op) {
                case 'is a':
                    if ('string' == right.nodeName && 'color' == right.string) {
                        return nodes['true'];
                    }
                    break;
                case '+':
                    switch (right.nodeName) {
                        case 'unit':
                            var n = right.val;
                            switch (right.type) {
                                case '%': return adjust(this, new nodes.String('lightness'), right);
                                case 'deg': return this.hsla.adjustHue(n).rgba;
                                default: return this.add(n, n, n, 0);
                            }
                        case 'rgba':
                            return this.add(right.r, right.g, right.b, right.a);
                        case 'hsla':
                            return this.hsla.add(right.h, right.s, right.l);
                    }
                    break;
                case '-':
                    switch (right.nodeName) {
                        case 'unit':
                            var n = right.val;
                            switch (right.type) {
                                case '%': return adjust(this, new nodes.String('lightness'), new nodes.Unit(-n, '%'));
                                case 'deg': return this.hsla.adjustHue(-n).rgba;
                                default: return this.sub(n, n, n, 0);
                            }
                        case 'rgba':
                            return this.sub(right.r, right.g, right.b, right.a);
                        case 'hsla':
                            return this.hsla.sub(right.h, right.s, right.l);
                    }
                    break;
                case '*':
                    switch (right.nodeName) {
                        case 'unit':
                            return this.multiply(right.val);
                    }
                    break;
                case '/':
                    switch (right.nodeName) {
                        case 'unit':
                            return this.divide(right.val);
                    }
                    break;
            }
            return Node.prototype.operate.call(this, op, right);
        };

        /**
        * Return #nnnnnn, #nnn, or rgba(n,n,n,n) string representation of the color.
        *
        * @return {String}
        * @api public
        */

        RGBA.prototype.toString = function () {
            function pad(n) {
                return n < 16
      ? '0' + n.toString(16)
      : n.toString(16);
            }

            if (1 == this.a) {
                var r = pad(this.r)
      , g = pad(this.g)
      , b = pad(this.b);

                // Compress
                if (r[0] == r[1] && g[0] == g[1] && b[0] == b[1]) {
                    return '#' + r[0] + g[0] + b[0];
                } else {
                    return '#' + r + g + b;
                }
            } else {
                return 'rgba('
      + this.r + ','
      + this.g + ','
      + this.b + ','
      + this.a.toFixed(2) + ')';
            }
        };

        /**
        * Return a `RGBA` from the given `hsla`.
        *
        * @param {HSLA} hsla
        * @return {RGBA}
        * @api public
        */

        exports.fromHSLA = function (hsla) {
            var h = hsla.h / 360
    , s = hsla.s / 100
    , l = hsla.l / 100
    , a = hsla.a;

            var m2 = l <= .5 ? l * (s + 1) : l + s - l * s
    , m1 = l * 2 - m2;

            var r = hue(h + 1 / 3) * 0xff
    , g = hue(h) * 0xff
    , b = hue(h - 1 / 3) * 0xff;

            function hue(h) {
                if (h < 0) ++h;
                if (h > 1) --h;
                if (h * 6 < 1) return m1 + (m2 - m1) * h * 6;
                if (h * 2 < 1) return m2;
                if (h * 3 < 2) return m1 + (m2 - m1) * (2 / 3 - h) * 6;
                return m1;
            }

            return new RGBA(r, g, b, a);
        };

        /**
        * Clamp `n` >= 0 and <= 255.
        *
        * @param {Number} n
        * @return {Number}
        * @api private
        */

        function clamp(n) {
            return Math.max(0, Math.min(n.toFixed(0), 255));
        }

        /**
        * Clamp alpha `n` >= 0 and <= 1.
        *
        * @param {Number} n
        * @return {Number}
        * @api private
        */

        function clampAlpha(n) {
            return Math.max(0, Math.min(n, 1));
        }
    }); // module: nodes/rgba.js


    require.register("nodes/root.js", function (module, exports, require) {


        /*!
        * Stylus - Root
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Root` node.
        *
        * @api public
        */

        var Root = module.exports = function Root() {
            this.nodes = [];
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Root.prototype.__proto__ = Node.prototype;

        /**
        * Push a `node` to this block.
        *
        * @param {Node} node
        * @api public
        */

        Root.prototype.push = function (node) {
            this.nodes.push(node);
        };

        /**
        * Return "root".
        *
        * @return {String}
        * @api public
        */

        Root.prototype.toString = function () {
            return '[Root]';
        };
    }); // module: nodes/root.js


    require.register("nodes/selector.js", function (module, exports, require) {


        /*!
        * Stylus - Selector
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Block = require('./block')
  , Node = require('./node');

        /**
        * Initialize a new `Selector` with the given `segs`.
        *
        * @param {Array} segs
        * @api public
        */

        var Selector = module.exports = function Selector(segs) {
            Node.call(this);
            this.inherits = true;
            this.segments = segs;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Selector.prototype.__proto__ = Node.prototype;

        /**
        * Return the selector string.
        *
        * @return {String}
        * @api public
        */

        Selector.prototype.toString = function () {
            return this.segments.join('');
        };

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Selector.prototype.clone = function () {
            var clone = new Selector;
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            clone.segments = this.segments.map(function (node) { return node.clone(); });
            return clone;
        };
    }); // module: nodes/selector.js


    require.register("nodes/string.js", function (module, exports, require) {


        /*!
        * Stylus - String
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , sprintf = require('../functions').s
  , utils = require('../utils')
  , nodes = require('./');

        /**
        * Initialize a new `String` with the given `val`.
        *
        * @param {String} val
        * @param {String} quote
        * @api public
        */

        var String = module.exports = function String(val, quote) {
            Node.call(this);
            this.val = val;
            this.string = val;
            this.quote = quote || "'";
        };

        /**
        * Inherit from `Node.prototype`.
        */

        String.prototype.__proto__ = Node.prototype;

        /**
        * Return quoted string.
        *
        * @return {String}
        * @api public
        */

        String.prototype.toString = function () {
            return this.quote + this.val + this.quote;
        };

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        String.prototype.clone = function () {
            var clone = new String(this.val, this.quote);
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };

        /**
        * Return Boolean based on the length of this string.
        *
        * @return {Boolean}
        * @api public
        */

        String.prototype.toBoolean = function () {
            return nodes.Boolean(this.val.length);
        };

        /**
        * Coerce `other` to a string.
        *
        * @param {Node} other
        * @return {String}
        * @api public
        */

        String.prototype.coerce = function (other) {
            switch (other.nodeName) {
                case 'string':
                    return other;
                case 'expression':
                    return new String(other.nodes.map(function (node) {
                        return this.coerce(node).val;
                    }, this).join(' '));
                default:
                    return new String(other.toString());
            }
        };

        /**
        * Operate on `right` with the given `op`.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        String.prototype.operate = function (op, right) {
            switch (op) {
                case '%':
                    var expr = new nodes.Expression;
                    expr.push(this);

                    // constructargs
                    var args = 'expression' == right.nodeName
        ? utils.unwrap(right).nodes
        : [right];

                    // apply
                    return sprintf.apply(null, [expr].concat(args));
                case '+':
                    return new String(this.val + this.coerce(right).val);
                default:
                    return Node.prototype.operate.call(this, op, right);
            }
        };
    }); // module: nodes/string.js


    require.register("nodes/ternary.js", function (module, exports, require) {


        /*!
        * Stylus - Ternary
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `Ternary` with `cond`, `trueExpr` and `falseExpr`.
        *
        * @param {Expression} cond
        * @param {Expression} trueExpr
        * @param {Expression} falseExpr
        * @api public
        */

        var Ternary = module.exports = function Ternary(cond, trueExpr, falseExpr) {
            Node.call(this);
            this.cond = cond;
            this.trueExpr = trueExpr;
            this.falseExpr = falseExpr;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Ternary.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Ternary.prototype.clone = function () {
            var clone = new Ternary(
      this.cond.clone()
    , this.trueExpr.clone()
    , this.falseExpr.clone());
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };
    }); // module: nodes/ternary.js


    require.register("nodes/unaryop.js", function (module, exports, require) {


        /*!
        * Stylus - UnaryOp
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node');

        /**
        * Initialize a new `UnaryOp` with `op`, and `expr`.
        *
        * @param {String} op
        * @param {Node} expr
        * @api public
        */

        var UnaryOp = module.exports = function UnaryOp(op, expr) {
            Node.call(this);
            this.op = op;
            this.expr = expr;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        UnaryOp.prototype.__proto__ = Node.prototype;

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        UnaryOp.prototype.clone = function () {
            var clone = new UnaryOp(this.op, this.expr.clone());
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };
    }); // module: nodes/unaryop.js


    require.register("nodes/unit.js", function (module, exports, require) {


        /*!
        * Stylus - Unit
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Node = require('./node')
  , nodes = require('./');

        /**
        * Initialize a new `Unit` with the given `val` and unit `type`
        * such as "px", "pt", "in", etc.
        *
        * @param {String} val
        * @param {String} type
        * @api public
        */

        var Unit = module.exports = function Unit(val, type) {
            Node.call(this);
            this.val = val;
            this.type = type;
        };

        /**
        * Inherit from `Node.prototype`.
        */

        Unit.prototype.__proto__ = Node.prototype;

        /**
        * Return Boolean based on the unit value.
        *
        * @return {Boolean}
        * @api public
        */

        Unit.prototype.toBoolean = function () {
            return nodes.Boolean(this.type
      ? true
      : this.val);
        };

        /**
        * Return unit string.
        *
        * @return {String}
        * @api public
        */

        Unit.prototype.toString = function () {
            var n = this.val;
            if ('px' == this.type) n = n.toFixed(0);
            return n + (this.type || '');
        };

        /**
        * Return a clone of this node.
        * 
        * @return {Node}
        * @api public
        */

        Unit.prototype.clone = function () {
            var clone = new Unit(this.val, this.type);
            clone.lineno = this.lineno;
            clone.filename = this.filename;
            return clone;
        };

        /**
        * Operate on `right` with the given `op`.
        *
        * @param {String} op
        * @param {Node} right
        * @return {Node}
        * @api public
        */

        Unit.prototype.operate = function (op, right) {
            var type = this.type || right.first.type;

            // swap color
            if ('rgba' == right.nodeName || 'hsla' == right.nodeName) {
                return right.operate(op, this);
            }

            // operate
            if (this.shouldCoerce(op)) {
                // percentages
                if (('-' == op || '+' == op) && '%' == right.type) {
                    right.val = this.val * (right.val / 100);
                } else {
                    right = this.coerce(right.first);
                }

                switch (op) {
                    case '-':
                        return new Unit(this.val - right.val, type);
                    case '+':
                        return new Unit(this.val + right.val, type);
                    case '/':
                        return new Unit(this.val / right.val, type);
                    case '*':
                        return new Unit(this.val * right.val, type);
                    case '%':
                        return new Unit(this.val % right.val, type);
                    case '**':
                        return new Unit(Math.pow(this.val, right.val), type);
                    case '..':
                    case '...':
                        var start = this.val
          , end = right.val
          , expr = new nodes.Expression
          , inclusive = '..' == op;
                        do {
                            expr.push(new nodes.Unit(start));
                        } while (inclusive ? ++start <= end : ++start < end);
                        return expr;
                }
            }

            return Node.prototype.operate.call(this, op, right);
        };

        /**
        * Coerce `other` unit to the same type as `this` unit.
        *
        * Supports:
        *
        *    mm -> cm | in
        *    cm -> mm | in
        *    in -> mm | cm
        *    
        *    ms -> s
        *    s  -> ms
        *    
        *    Hz  -> kHz
        *    kHz -> Hz
        *
        * @param {Unit} other
        * @return {Unit}
        * @api public
        */

        Unit.prototype.coerce = function (other) {
            if ('unit' == other.nodeName) {
                var a = this
      , b = other;
                switch (a.type) {
                    case 'mm':
                        switch (b.type) {
                            case 'cm':
                                return new nodes.Unit(b.val * 2.54, 'mm');
                            case 'in':
                                return new nodes.Unit(b.val * 25.4, 'mm');
                        }
                    case 'cm':
                        switch (b.type) {
                            case 'mm':
                                return new nodes.Unit(b.val / 10, 'cm');
                            case 'in':
                                return new nodes.Unit(b.val * 2.54, 'cm');
                        }
                    case 'in':
                        switch (b.type) {
                            case 'mm':
                                return new nodes.Unit(b.val / 25.4, 'in');
                            case 'cm':
                                return new nodes.Unit(b.val / 2.54, 'in');
                        }
                    case 'ms':
                        switch (b.type) {
                            case 's':
                                return new nodes.Unit(b.val * 1000, 'ms');
                        }
                    case 's':
                        switch (b.type) {
                            case 'ms':
                                return new nodes.Unit(b.val / 1000, 's');
                        }
                    case 'Hz':
                        switch (b.type) {
                            case 'kHz':
                                return new nodes.Unit(b.val * 1000, 'Hz');
                        }
                    case 'kHz':
                        switch (b.type) {
                            case 'Hz':
                                return new nodes.Unit(b.val / 1000, 'kHz');
                        }
                    default:
                        return new nodes.Unit(b.val, a.type);
                }
            } else if ('string' == other.nodeName) {
                var val = parseInt(other.val, 10);
                if (isNaN(val)) Node.prototype.coerce.call(this, other);
                return new nodes.Unit(val);
            } else {
                return Node.prototype.coerce.call(this, other);
            }
        };
    }); // module: nodes/unit.js


    require.register("parser.js", function (module, exports, require) {


        /*!
        * Stylus - Parser
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Lexer = require('./lexer')
  , nodes = require('./nodes')
  , Token = require('./token')
  , inspect = require('util').inspect
  , errors = require('./errors');

        // debuggers

        var debug = {
            lexer: require('debug')('stylus:lexer')
  , selector: require('debug')('stylus:parser:selector')
        };

        /**
        * Selector composite tokens.
        */

        var selectorTokens = [
    'ident'
  , 'string'
  , 'selector'
  , 'function'
  , 'comment'
  , 'boolean'
  , 'space'
  , 'color'
  , 'unit'
  , 'for'
  , 'in'
  , '['
  , ']'
  , '('
  , ')'
  , '+'
  , '-'
  , '*'
  , '*='
  , '<'
  , '>'
  , '='
  , ':'
  , '&'
  , '~'
  , '{'
  , '}'
];

        /**
        * CSS3 pseudo-selectors.
        */

        var pseudoSelectors = [
    'root'
  , 'nth-child'
  , 'nth-last-child'
  , 'nth-of-type'
  , 'nth-last-of-type'
  , 'first-child'
  , 'last-child'
  , 'first-of-type'
  , 'last-of-type'
  , 'only-child'
  , 'only-of-type'
  , 'empty'
  , 'link'
  , 'visited'
  , 'active'
  , 'hover'
  , 'focus'
  , 'target'
  , 'lang'
  , 'enabled'
  , 'disabled'
  , 'checked'
  , 'not'
];

        /**
        * Initialize a new `Parser` with the given `str` and `options`.
        *
        * @param {String} str
        * @param {Object} options
        * @api private
        */

        var Parser = module.exports = function Parser(str, options) {
            var self = this;
            options = options || {};
            this.lexer = new Lexer(str, options);
            this.root = options.root || new nodes.Root;
            this.state = ['root'];
            this.stash = [];
            this.parens = 0;
            this.css = 0;
            this.state.pop = function () {
                self.prevState = [].pop.call(this);
            };
        };

        /**
        * Parser prototype.
        */

        Parser.prototype = {

            /**
            * Constructor.
            */

            constructor: Parser,

            /**
            * Return current state.
            *
            * @return {String}
            * @api private
            */

            currentState: function () {
                return this.state[this.state.length - 1];
            },

            /**
            * Parse the input, then return the root node.
            *
            * @return {Node}
            * @api private
            */

            parse: function () {
                var block = this.parent = this.root;
                while ('eos' != this.peek().type) {
                    if (this.accept('newline')) continue;
                    var stmt = this.statement();
                    this.accept(';');
                    if (!stmt) this.error('unexpected token {peek}, not allowed at the root level');
                    block.push(stmt);
                }
                return block;
            },

            /**
            * Throw an `Error` with the given `msg`.
            *
            * @param {String} msg
            * @api private
            */

            error: function (msg) {
                var type = this.peek().type
      , val = undefined == this.peek().val
        ? ''
        : ' ' + this.peek().toString();
                if (val.trim() == type.trim()) val = '';
                throw new errors.ParseError(msg.replace('{peek}', '"' + type + val + '"'));
            },

            /**
            * Accept the given token `type`, and return it,
            * otherwise return `undefined`.
            *
            * @param {String} type
            * @return {Token}
            * @api private
            */

            accept: function (type) {
                if (type == this.peek().type) {
                    return this.next();
                }
            },

            /**
            * Expect token `type` and return it, throw otherwise.
            *
            * @param {String} type
            * @return {Token}
            * @api private
            */

            expect: function (type) {
                if (type != this.peek().type) {
                    this.error('expected "' + type + '", got {peek}');
                }
                return this.next();
            },

            /**
            * Get the next token.
            *
            * @return {Token}
            * @api private
            */

            next: function () {
                var tok = this.stash.length
      ? this.stash.pop()
      : this.lexer.next();
                nodes.lineno = tok.lineno;
                debug.lexer('%s %s', tok.type, tok.val || '');
                return tok;
            },

            /**
            * Peek with lookahead(1).
            *
            * @return {Token}
            * @api private
            */

            peek: function () {
                return this.lexer.peek();
            },

            /**
            * Lookahead `n` tokens.
            *
            * @param {Number} n
            * @return {Token}
            * @api private
            */

            lookahead: function (n) {
                return this.lexer.lookahead(n);
            },

            /**
            * Check if the token at `n` is a valid selector token. 
            *
            * @param {Number} n
            * @return {Boolean}
            * @api private
            */

            isSelectorToken: function (n) {
                var la = this.lookahead(n).type;
                switch (la) {
                    case 'for':
                        return this.bracketed;
                    case '[':
                        this.bracketed = true;
                        return true;
                    case ']':
                        this.bracketed = false;
                        return true;
                    default:
                        return ~selectorTokens.indexOf(la);
                }
            },

            /**
            * Check if the token at `n` is a pseudo selector.
            *
            * @param {Number} n
            * @return {Boolean}
            * @api private
            */

            isPseudoSelector: function (n) {
                return ~pseudoSelectors.indexOf(this.lookahead(n).val.name);
            },

            /**
            * Check if the current line contains `type`.
            *
            * @param {String} type
            * @return {Boolean}
            * @api private
            */

            lineContains: function (type) {
                var i = 1
      , la;

                while (la = this.lookahead(i++)) {
                    if (~['indent', 'outdent', 'newline'].indexOf(la.type)) return;
                    if (type == la.type) return true;
                }
            },

            /**
            * Valid selector tokens.
            */

            selectorToken: function () {
                if (this.isSelectorToken(1)) {
                    if ('{' == this.peek().type) {
                        // unclosed, must be a block
                        if (!this.lineContains('}')) return;
                        // check if ':' is within the braces.
                        // though not required by stylus, chances
                        // are if someone is using {} they will
                        // use css-style props, helping us with
                        // the ambiguity in this case
                        var i = 0
          , la;
                        while (la = this.lookahead(++i)) {
                            if ('}' == la.type) break;
                            if (':' == la.type) return;
                        }
                    }
                    return this.next();
                }
            },

            /**
            * Consume whitespace.
            */

            skipWhitespace: function () {
                while (~['space', 'indent', 'outdent', 'newline'].indexOf(this.peek().type))
                    this.next();
            },

            /**
            * Consume newlines.
            */

            skipNewlines: function () {
                while ('newline' == this.peek().type)
                    this.next();
            },

            /**
            * Consume spaces.
            */

            skipSpaces: function () {
                while ('space' == this.peek().type)
                    this.next();
            },

            /**
            * Check if the following sequence of tokens
            * forms a function definition, ie trailing
            * `{` or indentation.
            */

            looksLikeFunctionDefinition: function (i) {
                return 'indent' == this.lookahead(i).type
      || '{' == this.lookahead(i).type;
            },

            /**
            * Check if the following sequence of tokens
            * forms a selector.
            */

            looksLikeSelector: function () {
                var i = 1
      , brace;

                // Assume selector when an ident is
                // followed by a selector
                while ('ident' == this.lookahead(i).type
      && 'newline' == this.lookahead(i + 1).type) i += 2;

                while (this.isSelectorToken(i)
      || ',' == this.lookahead(i).type) {

                    if ('selector' == this.lookahead(i).type)
                        return true;

                    // the ':' token within braces signifies
                    // a selector. ex: "foo{bar:'baz'}"
                    if ('{' == this.lookahead(i).type) brace = true;
                    else if ('}' == this.lookahead(i).type) brace = false;
                    if (brace && ':' == this.lookahead(i).type) return true;

                    // '}' preceded by a space is considered a selector.
                    // for example "foo{bar}{baz}" may be a property,
                    // however "foo{bar} {baz}" is a selector
                    if ('space' == this.lookahead(i).type
        && '{' == this.lookahead(i + 1).type)
                        return true;

                    // Assume pseudo selectors are NOT properties
                    // as 'td:th-child(1)' may look like a property
                    // and function call to the parser otherwise
                    if (':' == this.lookahead(i++).type
        && this.isPseudoSelector(i))
                        return true;

                    if (',' == this.lookahead(i).type
        && 'newline' == this.lookahead(i + 1).type)
                        return true;
                }

                // Trailing comma
                if (',' == this.lookahead(i).type
      && 'newline' == this.lookahead(i + 1).type)
                    return true;

                // Trailing brace
                if ('{' == this.lookahead(i).type
      && 'newline' == this.lookahead(i + 1).type)
                    return true;

                // css-style mode, false on ; }
                if (this.css) {
                    if (';' == this.lookahead(i) ||
          '}' == this.lookahead(i))
                        return false;
                }

                // Trailing separators
                while (! ~[
        'indent'
      , 'outdent'
      , 'newline'
      , 'for'
      , 'if'
      , ';'
      , '}'].indexOf(this.lookahead(i).type))
                    ++i;

                if ('indent' == this.lookahead(i).type)
                    return true;
            },

            /**
            * Check if the current state supports selectors.
            */

            stateAllowsSelector: function () {
                switch (this.currentState()) {
                    case 'root':
                    case 'selector':
                    case 'conditional':
                    case 'keyframe':
                    case 'function':
                    case 'font-face':
                    case 'media':
                    case 'for':
                        return true;
                }
            },

            /**
            *   statement
            * | statement 'if' expression
            * | statement 'unless' expression
            */

            statement: function () {
                var stmt = this.stmt()
      , state = this.prevState
      , block
      , op;

                // special-case statements since it
                // is not an expression. We could
                // implement postfix conditionals at
                // the expression level, however they
                // would then fail to enclose properties
                if (this.allowPostfix) {
                    delete this.allowPostfix;
                    state = 'expression';
                }

                switch (state) {
                    case 'assignment':
                    case 'expression':
                    case 'function arguments':
                        while (op =
             this.accept('if')
          || this.accept('unless')
          || this.accept('for')) {
                            switch (op.type) {
                                case 'if':
                                case 'unless':
                                    stmt = new nodes.If(this.expression(), stmt);
                                    stmt.postfix = true;
                                    stmt.negate = 'unless' == op.type;
                                    this.accept(';');
                                    break;
                                case 'for':
                                    var key
                , val = this.id().name;
                                    if (this.accept(',')) key = this.id().name;
                                    this.expect('in');
                                    var each = new nodes.Each(val, key, this.expression());
                                    block = new nodes.Block;
                                    block.push(stmt);
                                    each.block = block;
                                    stmt = each;
                            }
                        }
                }

                return stmt;
            },

            /**
            *    ident
            *  | selector
            *  | literal
            *  | charset
            *  | import
            *  | media
            *  | scope
            *  | keyframes
            *  | page
            *  | for
            *  | if
            *  | unless
            *  | comment
            *  | expression
            *  | 'return' expression
            */

            stmt: function () {
                var type = this.peek().type;
                switch (type) {
                    case '-webkit-keyframes':
                    case 'keyframes':
                        return this.keyframes();
                    case 'font-face':
                        return this.fontface();
                    case 'comment':
                    case 'selector':
                    case 'literal':
                    case 'charset':
                    case 'import':
                    case 'extend':
                    case 'media':
                    case 'page':
                    case 'ident':
                    case 'scope':
                    case 'unless':
                    case 'function':
                    case 'for':
                    case 'if':
                        return this[type]();
                    case 'return':
                        return this['return']();
                    case '{':
                        return this.property();
                    default:
                        // Contextual selectors
                        if (this.stateAllowsSelector()) {
                            switch (type) {
                                case 'color':
                                case '~':
                                case '+':
                                case '>':
                                case '<':
                                case ':':
                                case '&':
                                case '[':
                                    return this.selector();
                                case '*':
                                    return this.property();
                                case '-':
                                    if ('{' == this.lookahead(2).type)
                                        return this.property();
                            }
                        }

                        // Expression fallback
                        var expr = this.expression();
                        if (expr.isEmpty) this.error('unexpected {peek}');
                        return expr;
                }
            },

            /**
            * indent (!outdent)+ outdent
            */

            block: function (node, scope) {
                var delim
      , stmt
      , block = this.parent = new nodes.Block(this.parent, node);

                if (false === scope) block.scope = false;

                // css-style
                if (this.accept('{')) {
                    this.css++;
                    delim = '}';
                    this.skipWhitespace();
                } else {
                    delim = 'outdent';
                    this.expect('indent');
                }

                while (delim != this.peek().type) {
                    // css-style
                    if (this.css) {
                        if (this.accept('newline')) continue;
                        stmt = this.statement();
                        this.accept(';');
                        this.skipWhitespace();
                    } else {
                        if (this.accept('newline')) continue;
                        stmt = this.statement();
                        this.accept(';');
                    }
                    if (!stmt) this.error('unexpected token {peek} in block');
                    block.push(stmt);
                }

                // css-style
                if (this.css) {
                    this.skipWhitespace();
                    this.expect('}');
                    this.skipSpaces();
                    this.css--;
                } else {
                    this.expect('outdent');
                }

                this.parent = block.parent;
                return block;
            },

            /**
            * comment space*
            */

            comment: function () {
                var node = this.next().val;
                this.skipSpaces();
                return node;
            },

            /**
            * for val (',' key) in expr
            */

            'for': function () {
                this.expect('for');
                var key
      , val = this.id().name;
                if (this.accept(',')) key = this.id().name;
                this.expect('in');
                var each = new nodes.Each(val, key, this.expression());
                this.state.push('for');
                each.block = this.block(each, false);
                this.state.pop();
                return each;
            },

            /**
            * return expression
            */

            'return': function () {
                this.expect('return');
                var expr = this.expression();
                return expr.isEmpty
      ? new nodes.Return
      : new nodes.Return(expr);
            },

            /**
            * unless expression block
            */

            unless: function () {
                this.expect('unless');
                var node = new nodes.If(this.expression(), true);
                this.state.push('conditional');
                node.block = this.block(node, false);
                this.state.pop();
                return node;
            },

            /**
            * if expression block (else block)?
            */

            'if': function () {
                this.expect('if');
                var node = new nodes.If(this.expression());
                this.state.push('conditional');
                node.block = this.block(node, false);
                while (this.accept('else')) {
                    if (this.accept('if')) {
                        var cond = this.expression()
          , block = this.block(node, false);
                        node.elses.push(new nodes.If(cond, block));
                    } else {
                        node.elses.push(this.block(node, false));
                        break;
                    }
                }
                this.state.pop();
                return node;
            },

            /**
            * scope
            */

            scope: function () {
                var val = this.expect('scope').val;
                this.selectorScope = val;
                return nodes['null'];
            },

            /**
            * extend
            */

            'extend': function () {
                var val = this.expect('extend').val;
                return new nodes.Extend(val);
            },

            /**
            * media
            */

            media: function () {
                var val = this.expect('media').val
      , media = new nodes.Media(val);
                this.state.push('media');
                media.block = this.block(media);
                this.state.pop();
                return media;
            },

            /**
            * fontface
            */

            fontface: function () {
                this.expect('font-face');
                var node = new nodes.FontFace;
                this.state.push('font-face');
                node.block = this.block(node);
                this.state.pop();
                return node;
            },

            /**
            * import expression
            */

            'import': function () {
                this.expect('import');
                this.allowPostfix = true;
                return new nodes.Import(this.expression());
            },

            /**
            * charset string
            */

            charset: function () {
                this.expect('charset');
                var str = this.expect('string').val;
                this.allowPostfix = true;
                return new nodes.Charset(str);
            },

            /**
            * page selector? block
            */

            page: function () {
                var selector;
                this.expect('page');
                if (this.accept(':')) {
                    var str = this.expect('ident').val.name;
                    selector = new nodes.Literal(':' + str);
                }
                var page = new nodes.Page(selector);
                this.skipSpaces();
                this.state.push('page');
                page.block = this.block(page);
                this.state.pop();
                return page;
            },

            /**
            * keyframes name (
            *  (unit | from | to)
            *  (',' (unit | from | to)*)
            *  block)+
            */

            keyframes: function () {
                var pos
      , tok = this.expect('keyframes')
      , keyframes = new nodes.Keyframes(this.id(), tok.val)
      , vals = [];

                // css-style
                if (this.accept('{')) {
                    this.css++;
                    this.skipWhitespace();
                } else {
                    this.expect('indent');
                }

                this.skipNewlines();

                while (pos = this.accept('unit') || this.accept('ident')) {
                    // from | to
                    if ('ident' == pos.type) {
                        this.accept('space');
                        switch (pos.val.name) {
                            case 'from':
                                pos = new nodes.Unit(0, '%');
                                break;
                            case 'to':
                                pos = new nodes.Unit(100, '%');
                                break;
                            default:
                                this.error('"' + pos.val.name + '" is invalid, use "from" or "to"');
                        }
                    } else {
                        pos = pos.val;
                    }

                    vals.push(pos);

                    // ','
                    if (this.accept(',') || this.accept('newline')) continue;

                    // block
                    this.state.push('keyframe');
                    var block = this.block(keyframes);
                    keyframes.push(vals, block);
                    vals = [];
                    this.state.pop();
                    if (this.css) this.skipWhitespace();
                    this.skipNewlines();
                }

                // css-style
                if (this.css) {
                    this.skipWhitespace();
                    this.expect('}');
                    this.css--;
                } else {
                    this.expect('outdent');
                }

                return keyframes;
            },

            /**
            * literal
            */

            literal: function () {
                return this.expect('literal').val;
            },

            /**
            * ident space?
            */

            id: function () {
                var tok = this.expect('ident');
                this.accept('space');
                return tok.val;
            },

            /**
            *   ident
            * | assignment
            * | property
            * | selector
            */

            ident: function () {
                var i = 2
      , la = this.lookahead(i).type;

                while ('space' == la) la = this.lookahead(++i).type;

                switch (la) {
                    // Assignment  
                    case '=':
                    case '?=':
                    case '-=':
                    case '+=':
                    case '*=':
                    case '/=':
                    case '%=':
                        return this.assignment();
                        // Assignment []=
                    case '[':
                        if (this._ident == this.peek()) return this.id();
                        while (']' != this.lookahead(i++).type
          && 'selector' != this.lookahead(i).type);
                        if ('=' == this.lookahead(i).type) {
                            this._ident = this.peek();
                            return this.expression();
                        } else if (this.looksLikeSelector() && this.stateAllowsSelector()) {
                            return this.selector();
                        }
                        // Operation
                    case '-':
                    case '+':
                    case '/':
                    case '*':
                    case '%':
                    case '**':
                    case 'and':
                    case 'or':
                    case '&&':
                    case '||':
                    case '>':
                    case '<':
                    case '>=':
                    case '<=':
                    case '!=':
                    case '==':
                    case '?':
                    case 'in':
                    case 'is a':
                    case 'is defined':
                        // Prevent cyclic .ident, return literal
                        if (this._ident == this.peek()) {
                            return this.id();
                        } else {
                            this._ident = this.peek();
                            switch (this.currentState()) {
                                // unary op or selector in property / for  
                                case 'for':
                                case 'selector':
                                    return this.property();
                                    // Part of a selector
                                case 'root':
                                case 'media':
                                case 'font-face':
                                    return this.selector();
                                case 'function':
                                    return this.looksLikeSelector()
                ? this.selector()
                : this.expression();
                                    // Do not disrupt the ident when an operand
                                default:
                                    return this.operand
                ? this.id()
                : this.expression();
                            }
                        }
                        // Selector or property
                    default:
                        switch (this.currentState()) {
                            case 'root':
                                return this.selector();
                            case 'for':
                            case 'page':
                            case 'media':
                            case 'font-face':
                            case 'selector':
                            case 'function':
                            case 'keyframe':
                            case 'conditional':
                                return this.property();
                            default:
                                return this.id();
                        }
                }
            },

            /**
            * '*'? (ident | '{' expression '}')+
            */

            interpolate: function () {
                var node
      , segs = []
      , star;

                star = this.accept('*');
                if (star) segs.push(new nodes.Literal('*'));

                while (true) {
                    if (this.accept('{')) {
                        this.state.push('interpolation');
                        segs.push(this.expression());
                        this.expect('}');
                        this.state.pop();
                    } else if (node = this.accept('-')) {
                        segs.push(new nodes.Literal('-'));
                    } else if (node = this.accept('ident')) {
                        segs.push(node.val);
                    } else {
                        break;
                    }
                }
                if (!segs.length) this.expect('ident');
                return segs;
            },

            /**
            *   property ':'? expression
            * | ident
            */

            property: function () {
                if (this.looksLikeSelector()) return this.selector();

                // property
                var ident = this.interpolate()
      , prop = new nodes.Property(ident)
      , ret = prop;

                // optional ':'
                this.accept('space');
                if (this.accept(':')) this.accept('space');

                this.state.push('property');
                this.inProperty = true;
                prop.expr = this.list();
                if (prop.expr.isEmpty) ret = ident[0];
                this.inProperty = false;
                this.allowPostfix = true;
                this.state.pop();

                // optional ';'
                this.accept(';');

                return ret;
            },

            /**
            *   selector ',' selector
            * | selector newline selector
            * | selector block
            */

            selector: function () {
                var tok
      , arr
      , group = new nodes.Group
      , scope = this.selectorScope
      , isRoot = 'root' == this.currentState();

                do {
                    arr = [];

                    // Clobber newline after ,
                    this.accept('newline');

                    // Selector candidates,
                    // stitched together to
                    // form a selector.
                    while (tok = this.selectorToken()) {
                        debug.selector('%s', tok);
                        // Selector component
                        switch (tok.type) {
                            case '{':
                                this.skipSpaces();
                                var expr = this.expression();
                                this.skipSpaces();
                                this.expect('}');
                                arr.push(expr);
                                break;
                            case 'comment':
                                arr.push(new nodes.Literal(tok.val.str));
                                break;
                            case 'color':
                                arr.push(new nodes.Literal(tok.val.raw));
                                break;
                            case 'space':
                                arr.push(new nodes.Literal(' '));
                                break;
                            case 'function':
                                arr.push(new nodes.Literal(tok.val.name + '('));
                                break;
                            case 'ident':
                                arr.push(new nodes.Literal(tok.val.name));
                                break;
                            default:
                                arr.push(new nodes.Literal(tok.val));
                                if (tok.space) arr.push(new nodes.Literal(' '));
                        }
                    }

                    // Push the selector
                    if (isRoot && scope) arr.unshift(new nodes.Literal(scope + ' '));
                    group.push(new nodes.Selector(arr));
                } while (this.accept(',') || this.accept('newline'));

                this.lexer.allowComments = false;
                this.state.push('selector');
                group.block = this.block(group);
                this.state.pop();


                return group;
            },

            /**
            * ident ('=' | '?=') expression
            */

            assignment: function () {
                var op
      , node
      , name = this.id().name;

                if (op =
         this.accept('=')
      || this.accept('?=')
      || this.accept('+=')
      || this.accept('-=')
      || this.accept('*=')
      || this.accept('/=')
      || this.accept('%=')) {
                    this.state.push('assignment');
                    var expr = this.list();
                    if (expr.isEmpty) this.error('invalid right-hand side operand in assignment, got {peek}')
                    node = new nodes.Ident(name, expr);
                    this.state.pop();

                    switch (op.type) {
                        case '?=':
                            var defined = new nodes.BinOp('is defined', node)
            , lookup = new nodes.Ident(name);
                            node = new nodes.Ternary(defined, lookup, node);
                            break;
                        case '+=':
                        case '-=':
                        case '*=':
                        case '/=':
                        case '%=':
                            node.val = new nodes.BinOp(op.type[0], new nodes.Ident(name), expr);
                            break;
                    }
                }

                return node;
            },

            /**
            *   definition
            * | call
            */

            'function': function () {
                var parens = 1
      , i = 2
      , tok;

                // Lookahead and determine if we are dealing
                // with a function call or definition. Here
                // we pair parens to prevent false negatives
                out:
                while (tok = this.lookahead(i++)) {
                    switch (tok.type) {
                        case 'function':
                        case '(':
                            ++parens;
                            break;
                        case ')':
                            if (! --parens) break out;
                            break;
                        case 'eos':
                            this.error('failed to find closing paren ")"');
                    }
                }

                // Definition or call
                switch (this.currentState()) {
                    case 'expression':
                        return this.functionCall();
                    default:
                        return this.looksLikeFunctionDefinition(i)
          ? this.functionDefinition()
          : this.expression();
                }
            },

            /**
            * url '(' (expression | urlchars)+ ')'
            */

            url: function () {
                this.expect('function');
                this.state.push('function arguments');
                var args = this.args();
                this.expect(')');
                this.state.pop();
                return new nodes.Call('url', args);
            },

            /**
            * ident '(' expression ')'
            */

            functionCall: function () {
                if ('url' == this.peek().val.name) return this.url();
                var name = this.expect('function').val.name;
                this.state.push('function arguments');
                this.parens++;
                var args = this.args();
                this.expect(')');
                this.parens--;
                this.state.pop();
                return new nodes.Call(name, args);
            },

            /**
            * ident '(' params ')' block
            */

            functionDefinition: function () {
                var name = this.expect('function').val.name;

                // params
                this.state.push('function params');
                this.skipWhitespace();
                var params = this.params();
                this.skipWhitespace();
                this.expect(')');
                this.state.pop();

                // Body
                this.state.push('function');
                var fn = new nodes.Function(name, params);
                fn.block = this.block(fn);
                this.state.pop();
                return new nodes.Ident(name, fn);
            },

            /**
            *   ident
            * | ident '...'
            * | ident '=' expression
            * | ident ',' ident
            */

            params: function () {
                var tok
      , node
      , params = new nodes.Params;
                while (tok = this.accept('ident')) {
                    this.accept('space');
                    params.push(node = tok.val);
                    if (this.accept('...')) {
                        node.rest = true;
                    } else if (this.accept('=')) {
                        node.val = this.expression();
                    }
                    this.skipWhitespace();
                    this.accept(',');
                    this.skipWhitespace();
                }
                return params;
            },

            /**
            * (ident ':')? expression (',' (ident ':')? expression)*
            */

            args: function () {
                var args = new nodes.Arguments
      , keyword;

                do {
                    // keyword
                    if ('ident' == this.peek().type && ':' == this.lookahead(2).type) {
                        keyword = this.next().val.string;
                        this.expect(':');
                        args.map[keyword] = this.expression();
                        // arg
                    } else {
                        args.push(this.expression());
                    }
                } while (this.accept(','));

                return args;
            },

            /**
            * expression (',' expression)*
            */

            list: function () {
                var node = this.expression();
                while (this.accept(',')) {
                    if (node.isList) {
                        list.push(this.expression());
                    } else {
                        var list = new nodes.Expression(true);
                        list.push(node);
                        list.push(this.expression());
                        node = list;
                    }
                }
                return node;
            },

            /**
            * negation+
            */

            expression: function () {
                var node
      , expr = new nodes.Expression;
                this.state.push('expression');
                while (node = this.negation()) {
                    if (!node) this.error('unexpected token {peek} in expression');
                    expr.push(node);
                }
                this.state.pop();
                return expr;
            },

            /**
            *   'not' ternary
            * | ternary
            */

            negation: function () {
                if (this.accept('not')) {
                    return new nodes.UnaryOp('!', this.negation());
                }
                return this.ternary();
            },

            /**
            * logical ('?' expression ':' expression)?
            */

            ternary: function () {
                var node = this.logical();
                if (this.accept('?')) {
                    var trueExpr = this.expression();
                    this.expect(':');
                    var falseExpr = this.expression();
                    node = new nodes.Ternary(node, trueExpr, falseExpr);
                }
                return node;
            },

            /**
            * typecheck (('&&' | '||') typecheck)*
            */

            logical: function () {
                var op
      , node = this.typecheck();
                while (op = this.accept('&&') || this.accept('||')) {
                    node = new nodes.BinOp(op.type, node, this.typecheck());
                }
                return node;
            },

            /**
            * equality ('is a' equality)*
            */

            typecheck: function () {
                var op
      , node = this.equality();
                while (op = this.accept('is a')) {
                    this.operand = true;
                    if (!node) this.error('illegal unary "' + op + '", missing left-hand operand');
                    node = new nodes.BinOp(op.type, node, this.equality());
                    this.operand = false;
                }
                return node;
            },

            /**
            * in (('==' | '!=') in)*
            */

            equality: function () {
                var op
      , node = this['in']();
                while (op = this.accept('==') || this.accept('!=')) {
                    this.operand = true;
                    if (!node) this.error('illegal unary "' + op + '", missing left-hand operand');
                    node = new nodes.BinOp(op.type, node, this['in']());
                    this.operand = false;
                }
                return node;
            },

            /**
            * relational ('in' relational)*
            */

            'in': function () {
                var node = this.relational();
                while (this.accept('in')) {
                    this.operand = true;
                    if (!node) this.error('illegal unary "in", missing left-hand operand');
                    node = new nodes.BinOp('in', node, this.relational());
                    this.operand = false;
                }
                return node;
            },

            /**
            * range (('>=' | '<=' | '>' | '<') range)*
            */

            relational: function () {
                var op
      , node = this.range();
                while (op =
         this.accept('>=')
      || this.accept('<=')
      || this.accept('<')
      || this.accept('>')
      ) {
                    this.operand = true;
                    if (!node) this.error('illegal unary "' + op + '", missing left-hand operand');
                    node = new nodes.BinOp(op.type, node, this.range());
                    this.operand = false;
                }
                return node;
            },

            /**
            * additive (('..' | '...') additive)*
            */

            range: function () {
                var op
      , node = this.additive();
                if (op = this.accept('...') || this.accept('..')) {
                    this.operand = true;
                    if (!node) this.error('illegal unary "' + op + '", missing left-hand operand');
                    node = new nodes.BinOp(op.val, node, this.additive());
                    this.operand = false;
                }
                return node;
            },

            /**
            * multiplicative (('+' | '-') multiplicative)*
            */

            additive: function () {
                var op
      , node = this.multiplicative();
                while (op = this.accept('+') || this.accept('-')) {
                    this.operand = true;
                    node = new nodes.BinOp(op.type, node, this.multiplicative());
                    this.operand = false;
                }
                return node;
            },

            /**
            * defined (('**' | '*' | '/' | '%') defined)*
            */

            multiplicative: function () {
                var op
      , node = this.defined();
                while (op =
         this.accept('**')
      || this.accept('*')
      || this.accept('/')
      || this.accept('%')) {
                    this.operand = true;
                    if ('/' == op && this.inProperty && !this.parens) {
                        this.stash.push(new Token('literal', new nodes.Literal('/')));
                        this.operand = false;
                        return node;
                    } else {
                        if (!node) this.error('illegal unary "' + op + '", missing left-hand operand');
                        node = new nodes.BinOp(op.type, node, this.defined());
                        this.operand = false;
                    }
                }
                return node;
            },

            /**
            *    unary 'is defined'
            *  | unary
            */

            defined: function () {
                var node = this.unary();
                if (this.accept('is defined')) {
                    if (!node) this.error('illegal unary "is defined", missing left-hand operand');
                    node = new nodes.BinOp('is defined', node);
                }
                return node;
            },

            /**
            *   ('!' | '~' | '+' | '-') unary
            * | subscript
            */

            unary: function () {
                var op
      , node;
                if (op =
         this.accept('!')
      || this.accept('~')
      || this.accept('+')
      || this.accept('-')) {
                    this.operand = true;
                    node = new nodes.UnaryOp(op.type, this.unary());
                    this.operand = false;
                    return node;
                }
                return this.subscript();
            },

            /**
            *   primary ('[' expression ']' '='?)+
            * | primary
            */

            subscript: function () {
                var node = this.primary();
                while (this.accept('[')) {
                    node = new nodes.BinOp('[]', node, this.expression());
                    this.expect(']');
                    // TODO: TernaryOp :)
                    if (this.accept('=')) {
                        node.op += '=';
                        node.val = this.expression();
                    }
                }
                return node;
            },

            /**
            *   unit
            * | null
            * | color
            * | string
            * | ident
            * | boolean
            * | literal
            * | '(' expression ')' '%'?
            */

            primary: function () {
                var op
      , node;

                // Parenthesis
                if (this.accept('(')) {
                    ++this.parens;
                    var expr = this.expression();
                    this.expect(')');
                    --this.parens;
                    if (this.accept('%')) expr.push(new nodes.Ident('%'));
                    return expr;
                }

                // Primitive
                switch (this.peek().type) {
                    case 'null':
                    case 'unit':
                    case 'color':
                    case 'string':
                    case 'literal':
                    case 'boolean':
                        return this.next().val;
                    case 'ident':
                        return this.ident();
                    case 'function':
                        return this.functionCall();
                }
            }
        };
    }); // module: parser.js


    require.register("stack/index.js", function (module, exports, require) {


        /*!
        * Stylus - Stack
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Frame = require('./frame');

        /**
        * Initialize a new `Stack`.
        *
        * @api private
        */

        var Stack = module.exports = function Stack() {
            Array.apply(this, arguments);
        };

        /**
        * Inherit from `Array.prototype`.
        */

        Stack.prototype.__proto__ = Array.prototype;

        /**
        * Push the given `frame`.
        *
        * @param {Frame} frame
        * @api public
        */

        Stack.prototype.push = function (frame) {
            frame.stack = this;
            frame.parent = this.currentFrame;
            return [].push.apply(this, arguments);
        };

        /**
        * Return the current stack `Frame`.
        *
        * @return {Frame}
        * @api private
        */

        Object.defineProperty(Stack.prototype, 'currentFrame', { configurable: true,
            get: function () {
                return this[this.length - 1];
            } 
        });

        /**
        * Lookup stack frame for the given `block`.
        *
        * @param {Block} block
        * @return {Frame}
        * @api private
        */

        Stack.prototype.getBlockFrame = function (block) {
            for (var i = 0; i < this.length; ++i) {
                if (block == this[i].block) {
                    return this[i];
                }
            }
        };

        /**
        * Lookup the given local variable `name`, relative
        * to the lexical scope of the current frame's `Block`.
        *
        * When the result of a lookup is an identifier
        * a recursive lookup is performed, defaulting to
        * returning the identifier itself.
        *
        * @param {String} name
        * @return {Node}
        * @api private
        */

        Stack.prototype.lookup = function (name) {
            var block = this.currentFrame.block
    , val
    , ret;

            do {
                var frame = this.getBlockFrame(block);
                if (frame && (val = frame.lookup(name))) {
                    switch (val.first.nodeName) {
                        case 'ident':
                            return this.lookup(val.first.name) || val;
                        default:
                            return val;
                    }
                }
            } while (block = block.parent);
        };

        /**
        * Custom inspect.
        *
        * @return {String}
        * @api private
        */

        Stack.prototype.inspect = function () {
            return this.reverse().map(function (frame) {
                return frame.inspect();
            }).join('\n');
        };

        /**
        * Return stack string formatted as:
        *
        *   at <context> (<filename>:<lineno>)
        *
        * @return {String}
        * @api private
        */

        Stack.prototype.toString = function () {
            var block
    , node
    , buf = []
    , location
    , len = this.length;

            while (len--) {
                block = this[len].block;
                if (node = block.node) {
                    location = '(' + node.filename + ':' + (node.lineno + 1) + ')';
                    switch (node.nodeName) {
                        case 'function':
                            buf.push('    at ' + node.name + '() ' + location);
                            break;
                        case 'group':
                            buf.push('    at "' + node.nodes[0].val + '" ' + location);
                            break;
                    }
                }
            }

            return buf.join('\n');
        };
    }); // module: stack/index.js


    require.register("stack/frame.js", function (module, exports, require) {


        /*!
        * Stylus - stack - Frame
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Scope = require('./scope')
  , blocks = require('../nodes');

        /**
        * Initialize a new `Frame` with the given `block`.
        *
        * @param {Block} block
        * @api private
        */

        var Frame = module.exports = function Frame(block) {
            this._scope = false === block.scope
    ? null
    : new Scope;
            this.block = block;
        };

        /**
        * Return this frame's scope or the parent scope
        * for scope-less blocks.
        *
        * @return {Scope}
        * @api public
        */

        Object.defineProperty(Frame.prototype, 'scope', { configurable: true,
            get: function () {
                return this._scope || this.parent.scope;
            } 
        });

        /**
        * Lookup the given local variable `name`.
        *
        * @param {String} name
        * @return {Node}
        * @api private
        */

        Frame.prototype.lookup = function (name) {
            return this.scope.lookup(name)
        };

        /**
        * Custom inspect.
        *
        * @return {String}
        * @api public
        */

        Frame.prototype.inspect = function () {
            return '[Frame '
    + (false === this.block.scope
        ? 'scope-less'
        : this.scope.inspect())
    + ']';
        };
    }); // module: stack/frame.js


    require.register("stack/scope.js", function (module, exports, require) {


        /*!
        * Stylus - stack - Scope
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Initialize a new `Scope`.
        *
        * @api private
        */

        var Scope = module.exports = function Scope() {
            this.locals = {};
        };

        /**
        * Add `ident` node to the current scope.
        *
        * @param {Ident} ident
        * @api private
        */

        Scope.prototype.add = function (ident) {
            this.locals[ident.name] = ident.val;
        };

        /**
        * Lookup the given local variable `name`.
        *
        * @param {String} name
        * @return {Node}
        * @api private
        */

        Scope.prototype.lookup = function (name) {
            return this.locals[name];
        };

        /**
        * Custom inspect.
        *
        * @return {String}
        * @api public
        */

        Scope.prototype.inspect = function () {
            var keys = Object.keys(this.locals).map(function (key) { return '@' + key; });
            return '[Scope'
    + (keys.length ? ' ' + keys.join(', ') : '')
    + ']';
        };
    }); // module: stack/scope.js


    require.register("convert/css.js", function (module, exports, require) {


        /*!
        * Stylus - css to stylus conversion
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Convert the given `css` to stylus source.
        *
        * @param {String} css
        * @return {String}
        * @api public
        */

        module.exports = function (css) {
            return new Converter(css).stylus();
        };

        /**
        * Initialize a new `Converter` with the given `css`.
        *
        * @param {String} css
        * @api private
        */

        function Converter(css) {
            var cssom = require('cssom');
            this.css = css;
            this.types = cssom.CSSRule;
            this.root = cssom.parse(css);
            this.indents = 0;
        }

        /**
        * Convert to stylus.
        *
        * @return {String}
        * @api private
        */

        Converter.prototype.stylus = function () {
            return this.visitRules(this.root.cssRules);
        };

        /**
        * Return indent string.
        *
        * @return {String}
        * @api private
        */

        Object.defineProperty(Converter.prototype, 'indent', { configurable: true,
            get: function () {
                return Array(this.indents + 1).join('  ');
            } 
        });

        /**
        * Visit `node`.
        *
        * @param {CSSRule} node
        * @return {String}
        * @api private
        */

        Converter.prototype.visit = function (node) {
            switch (node.type) {
                case this.types.STYLE_RULE:
                    return this.visitStyle(node);
                case this.types.MEDIA_RULE:
                    return this.visitMedia(node);
            }
        };

        /**
        * Visit the rules on `node`.
        *
        * @param {CSSRule} node
        * @return {String}
        * @api private
        */

        Converter.prototype.visitRules = function (node) {
            var buf = '';
            for (var i = 0, len = node.length; i < len; ++i) {
                buf += this.visit(node[i]);
            }
            return buf;
        };

        /**
        * Visit CSSMediaRule `node`.
        *
        * @param {CSSMediaRule} node
        * @return {String}
        * @api private
        */

        Converter.prototype.visitMedia = function (node) {
            var buf = this.indent + '@media ';
            for (var i = 0, len = node.media.length; i < len; ++i) {
                buf += node.media[i];
            }
            buf += '\n';
            ++this.indents;
            buf += this.visitRules(node.cssRules);
            --this.indents;
            return buf;
        };

        /**
        * Visit CSSStyleRule `node`.`
        *
        * @param {CSSStyleRule} node
        * @return {String}
        * @api private
        */

        Converter.prototype.visitStyle = function (node) {
            var buf = this.indent + node.selectorText + '\n';
            ++this.indents;
            for (var i = 0, len = node.style.length; i < len; ++i) {
                var prop = node.style[i]
      , val = node.style[prop];
                if (prop) {
                    buf += this.indent + prop + ': ' + val + '\n';
                }
            }
            --this.indents;
            return buf + '\n';
        };
    }); // module: convert/css.js


    require.register("token.js", function (module, exports, require) {


        /*!
        * Stylus - Token
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var inspect = require('util').inspect;

        /**
        * Initialize a new `Token` with the given `type` and `val`.
        *
        * @param {String} type
        * @param {Mixed} val
        * @api private
        */

        var Token = exports = module.exports = function Token(type, val) {
            this.type = type;
            this.val = val;
        };

        /**
        * Custom inspect.
        *
        * @return {String}
        * @api public
        */

        Token.prototype.inspect = function () {
            var val = ' ' + inspect(this.val);
            return '[Token:' + this.lineno + ' '
    + '\x1b[32m' + this.type + '\x1b[0m'
    + '\x1b[33m' + (this.val ? val : '') + '\x1b[0m'
    + ']';
        };

        /**
        * Return type or val.
        *
        * @return {String}
        * @api public
        */

        Token.prototype.toString = function () {
            return (undefined === this.val
    ? this.type
    : this.val).toString();
        };
    }); // module: token.js


    require.register("utils.js", function (module, exports, require) {


        /*!
        * Stylus - utils
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var nodes = require('./nodes')
  , join = require('path').join
  , fs = require('fs');

        /**
        * Check if `path` looks absolute.
        *
        * @param {String} path
        * @return {Boolean}
        * @api private
        */

        exports.absolute = function (path) {
            return /^([a-z]:\\)|\//i.test(path);
        };

        /**
        * Attempt to lookup `path` within `paths` from tail to head.
        * Optionally a path to `ignore` may be passed.
        *
        * @param {String} path
        * @param {String} paths
        * @param {String} ignore
        * @return {String}
        * @api private
        */

        exports.lookup = function (path, paths, ignore) {
            var lookup
    , i = paths.length;

            // Absolute
            if (exports.absolute(path)) {
                try {
                    fs.statSync(path);
                    return path;
                } catch (err) {
                    // Ignore, continue on
                    // to trying relative lookup.
                    // Needed for url(/images/foo.png)
                    // for example
                }
            }

            // Relative
            while (i--) {
                try {
                    lookup = join(paths[i], path);
                    if (ignore == lookup) continue;
                    fs.statSync(lookup);
                    return lookup;
                } catch (err) {
                    // Ignore
                }
            }
        };

        /**
        * Format the given `err` with the given `options`.
        *
        * Options:
        *
        *   - `filename`   context filename
        *   - `context`    context line count [8]
        *   - `lineno`     context line number
        *   - `input`        input string
        *
        * @param {Error} err
        * @param {Object} options
        * @return {Error}
        * @api private
        */

        exports.formatException = function (err, options) {
            var lineno = options.lineno
    , filename = options.filename
    , str = options.input
    , context = options.context || 8
    , context = context / 2
    , lines = ('\n' + str).split('\n')
    , start = Math.max(lineno - context, 1)
    , end = Math.min(lines.length, lineno + context)
    , pad = end.toString().length;

            var context = lines.slice(start, end).map(function (line, i) {
                var curr = i + start;
                return (curr == lineno ? ' > ' : '   ')
      + Array(pad - curr.toString().length + 1).join(' ')
      + curr
      + '| '
      + line;
            }).join('\n');

            err.message = filename
    + ':' + lineno
    + '\n' + context
    + '\n\n' + err.message + '\n'
    + (err.stylusStack ? err.stylusStack + '\n' : '');

            return err;
        };

        /**
        * Assert that `node` is of the given `type`, or throw.
        *
        * @param {Node} node
        * @param {Function} type
        * @param {String} param
        * @api public
        */

        exports.assertType = function (node, type, param) {
            exports.assertPresent(node, param);
            if (node.nodeName == type) return;
            var actual = node.nodeName
    , msg = 'expected "'
      + param + '" to be a '
      + type + ', but got '
      + actual + ':' + node;
            throw new Error('TypeError: ' + msg);
        };

        /**
        * Assert that `node` is a `String` or `Ident`.
        *
        * @param {Node} node
        * @param {String} param
        * @api public
        */

        exports.assertString = function (node, param) {
            exports.assertPresent(node, param);
            switch (node.nodeName) {
                case 'string':
                case 'ident':
                case 'literal':
                    return;
                default:
                    var actual = node.nodeName
        , msg = 'expected string, ident or literal, but got ' + actual + ':' + node;
                    throw new Error('TypeError: ' + msg);
            }
        };

        /**
        * Assert that `node` is a `RGBA` or `HSLA`.
        *
        * @param {Node} node
        * @param {String} param
        * @api public
        */

        exports.assertColor = function (node, param) {
            exports.assertPresent(node, param);
            switch (node.nodeName) {
                case 'rgba':
                case 'hsla':
                    return;
                default:
                    var actual = node.nodeName
        , msg = 'expected rgba or hsla, but got ' + actual + ':' + node;
                    throw new Error('TypeError: ' + msg);
            }
        };

        /**
        * Assert that param `name` is given, aka the `node` is passed.
        *
        * @param {Node} node
        * @param {String} name
        * @api public
        */

        exports.assertPresent = function (node, name) {
            if (node) return;
            if (name) throw new Error('"' + name + '" argument required');
            throw new Error('argument missing');
        };

        /**
        * Unwrap `expr`.
        *
        * Takes an expressions with length of 1
        * such as `((1 2 3))` and unwraps it to `(1 2 3)`.
        *
        * @param {Expression} expr
        * @return {Node}
        * @api public
        */

        exports.unwrap = function (expr) {
            // explicitly preserve the expression
            if (expr.preserve) return expr;
            if ('arguments' != expr.nodeName && 'expression' != expr.nodeName) return expr;
            if (1 != expr.nodes.length) return expr;
            if ('arguments' != expr.nodes[0].nodeName && 'expression' != expr.nodes[0].nodeName) return expr;
            return exports.unwrap(expr.nodes[0]);
        };

        /**
        * Coerce JavaScript values to their Stylus equivalents.
        *
        * @param {Mixed} val
        * @return {Node}
        * @api public
        */

        exports.coerce = function (val) {
            switch (typeof val) {
                case 'function':
                    return val;
                case 'string':
                    return new nodes.String(val);
                case 'boolean':
                    return new nodes.Boolean(val);
                case 'number':
                    return new nodes.Unit(val);
                default:
                    if (null == val) return nodes['null'];
                    if (Array.isArray(val)) return exports.coerceArray(val);
                    if (val.nodeName) return val;
                    return exports.coerceObject(val);
            }
        };

        /**
        * Coerce a javascript `Array` to a Stylus `Expression`.
        *
        * @param {Array} val
        * @return {Expression}
        * @api private
        */

        exports.coerceArray = function (val) {
            var expr = new nodes.Expression;
            val.forEach(function (val) {
                expr.push(exports.coerce(val));
            });
            return expr;
        };

        /**
        * Coerce a javascript object to a Stylus `Expression`.
        *
        * For example `{ foo: 'bar', bar: 'baz' }` would become
        * the expression `(foo 'bar') (bar 'baz')`.
        *
        * @param {Object} obj
        * @return {Expression}
        * @api public
        */

        exports.coerceObject = function (obj) {
            var expr = new nodes.Expression
    , val;

            for (var key in obj) {
                val = exports.coerce(obj[key]);
                key = new nodes.Ident(key);
                expr.push(exports.coerceArray([key, val]));
            }

            return expr;
        };

        /**
        * Return param names for `fn`.
        *
        * @param {Function} fn
        * @return {Array}
        * @api private
        */

        exports.params = function (fn) {
            return fn
    .toString()
    .match(/\(([^)]*)\)/)[1].split(/ *, */);
        };

        /**
        * Merge object `b` with `a`.
        *
        * @param {Object} a
        * @param {Object} b
        * @return {Object} a
        * @api private
        */

        exports.merge = function (a, b) {
            for (var k in b) a[k] = b[k];
            return a;
        }
    }); // module: utils.js


    require.register("visitor/index.js", function (module, exports, require) {


        /*!
        * Stylus - Visitor
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Initialize a new `Visitor` with the given `root` Node.
        *
        * @param {Node} root
        * @api private
        */

        var Visitor = module.exports = function Visitor(root) {
            this.root = root;
        };

        /**
        * Visit the given `node`.
        *
        * @param {Node|Array} node
        * @api public
        */

        Visitor.prototype.visit = function (node, fn) {
            var method = 'visit' + node.constructor.name;
            if (this[method]) return this[method](node);
            return node;
        };

    }); // module: visitor/index.js


    require.register("visitor/evaluator.js", function (module, exports, require) {


        /*!
        * Stylus - Evaluator
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Visitor = require('./')
  , units = require('../units')
  , nodes = require('../nodes')
  , Stack = require('../stack')
  , Frame = require('../stack/frame')
  , Scope = require('../stack/scope')
  , utils = require('../utils')
  , bifs = require('../functions')
  , dirname = require('path').dirname
  , join = require('path').join
  , colors = require('../colors')
  , debug = require('debug')('stylus:evaluator')
  , fs = require('fs');

        /**
        * Initialize a new `Evaluator` with the given `root` Node
        * and the following `options`.
        *
        * Options:
        *
        *   - `compress`  Compress the css output, defaults to false
        *   - `warn`  Warn the user of duplicate function definitions etc
        *
        * @param {Node} root
        * @api private
        */

        var Evaluator = module.exports = function Evaluator(root, options) {
            options = options || {};
            Visitor.call(this, root);
            this.stack = new Stack;
            this.imports = options.imports || [];
            this.functions = options.functions || {};
            this.globals = options.globals || {};
            this.paths = options.paths || [];
            this.filename = options.filename;
            this.includeCSS = options['include css'];
            this.paths.push(dirname(options.filename || '.'));
            this.stack.push(this.global = new Frame(root));
            this.warnings = options.warn;
            this.options = options;
            this.calling = []; // TODO: remove, use stack
            this.importStack = [];
            this['return'] = 0;
        };

        /**
        * Inherit from `Visitor.prototype`.
        */

        Evaluator.prototype.__proto__ = Visitor.prototype;

        /**
        * Proxy visit to expose node line numbers.
        *
        * @param {Node} node
        * @return {Node}
        * @api private
        */

        var visit = Visitor.prototype.visit;
        Evaluator.prototype.visit = function (node) {
            try {
                return visit.call(this, node);
            } catch (err) {
                if (err.filename) throw err;
                err.lineno = node.lineno;
                err.filename = node.filename;
                err.stylusStack = this.stack.toString();
                try {
                    err.input = fs.readFileSync(err.filename, 'utf8');
                } catch (err) {
                    // ignore
                }
                throw err;
            }
        };

        /**
        * Perform evaluation setup:
        *
        *   - populate global scope
        *   - iterate imports
        *
        * @api private
        */

        Evaluator.prototype.setup = function () {
            this.populateGlobalScope();
            this.imports.forEach(function (file) {
                var expr = new nodes.Expression;
                expr.push(new nodes.String(file));
                this.visit(new nodes.Import(expr));
            }, this);
        };

        /**
        * Populate the global scope with:
        * 
        *   - css colors
        *   - user-defined globals
        * 
        * @api private
        */

        Evaluator.prototype.populateGlobalScope = function () {
            var scope = this.global.scope;

            // colors
            Object.keys(colors).forEach(function (name) {
                var rgb = colors[name]
      , rgba = new nodes.RGBA(rgb[0], rgb[1], rgb[2], 1)
      , node = new nodes.Ident(name, rgba);
                scope.add(node);
            });

            // user-defined globals
            var globals = this.globals;
            Object.keys(globals).forEach(function (name) {
                scope.add(new nodes.Ident(name, globals[name]));
            });
        };

        /**
        * Evaluate the tree.
        *
        * @return {Node}
        * @api private
        */

        Evaluator.prototype.evaluate = function () {
            debug('eval %s', this.filename);
            this.setup();
            return this.visit(this.root);
        };

        /**
        * Visit Group.
        */

        Evaluator.prototype.visitGroup = function (group) {
            group.nodes = group.nodes.map(function (selector) {
                selector.val = this.interpolate(selector);
                debug('ruleset %s', selector.val);
                return selector;
            }, this);

            group.block = this.visit(group.block);
            return group;
        };

        /**
        * Visit Charset.
        */

        Evaluator.prototype.visitCharset = function (charset) {
            return charset;
        };

        /**
        * Visit Return.
        */

        Evaluator.prototype.visitReturn = function (ret) {
            ret.expr = this.visit(ret.expr);
            throw ret;
        };

        /**
        * Visit Media.
        */

        Evaluator.prototype.visitMedia = function (media) {
            media.block = this.visit(media.block);
            return media;
        };

        /**
        * Visit FontFace.
        */

        Evaluator.prototype.visitFontFace = function (face) {
            face.block = this.visit(face.block);
            return face;
        };

        /**
        * Visit FontFace.
        */

        Evaluator.prototype.visitPage = function (page) {
            page.block = this.visit(page.block);
            return page;
        };

        /**
        * Visit Keyframes.
        */

        Evaluator.prototype.visitKeyframes = function (keyframes) {
            if (keyframes.fabricated) return keyframes;
            keyframes.name = this.visit(keyframes.name).first.name;

            keyframes.frames = keyframes.frames.map(function (frame) {
                frame.block = this.visit(frame.block);
                return frame;
            }, this);

            if ('official' != keyframes.prefix) return keyframes;

            this.vendors.forEach(function (prefix) {
                var node = keyframes.clone();
                node.prefix = prefix;
                node.fabricated = true;
                this.currentBlock.push(node);
            }, this);

            return nodes['null'];
        };

        /**
        * Visit Function.
        */

        Evaluator.prototype.visitFunction = function (fn) {
            // check local
            var local = this.stack.currentFrame.scope.lookup(fn.name);
            if (local) this.warn('local ' + local.nodeName + ' "' + fn.name + '" previously defined in this scope');

            // user-defined
            var user = this.functions[fn.name];
            if (user) this.warn('user-defined function "' + fn.name + '" is already defined');

            // BIF
            var bif = bifs[fn.name];
            if (bif) this.warn('built-in function "' + fn.name + '" is already defined');

            return fn;
        };

        /**
        * Visit Each.
        */

        Evaluator.prototype.visitEach = function (each) {
            this['return']++;
            var expr = utils.unwrap(this.visit(utils.unwrap(each.expr)))
    , len = expr.nodes.length
    , val = new nodes.Ident(each.val)
    , key = new nodes.Ident(each.key || '__index__')
    , scope = this.currentScope
    , block = this.currentBlock
    , vals = []
    , body;
            this['return']--;

            each.block.scope = false;
            for (var i = 0; i < len; ++i) {
                val.val = expr.nodes[i];
                key.val = new nodes.Unit(i);
                scope.add(val);
                scope.add(key);
                body = this.visit(each.block.clone());
                vals = vals.concat(body.nodes);
            }

            this.mixin(vals, block);
            return vals[vals.length - 1] || nodes['null'];
        };

        /**
        * Visit Call.
        */

        Evaluator.prototype.visitCall = function (call) {
            debug('call %s', call);
            var fn = this.lookup(call.name)
    , ret;

            // url()
            this.ignoreColors = 'url' == call.name;

            // Variable function
            if (fn && 'expression' == fn.nodeName) {
                fn = fn.nodes[0];
            }

            // Not a function? try user-defined or built-ins
            if (fn && 'function' != fn.nodeName) {
                fn = this.lookupFunction(call.name);
            }

            // Undefined function, render literal css
            if (!fn || fn.nodeName != 'function') {
                debug('%s is undefined', call);
                var ret = this.literalCall(call);
                this.ignoreColors = false;
                return ret;
            }

            this.calling.push(call.name);

            // Massive stack
            if (this.calling.length > 200) {
                throw new RangeError('Maximum stylus call stack size exceeded');
            }

            // First node in expression
            if ('expression' == fn.nodeName) fn = fn.first;

            // Evaluate arguments
            this['return']++;
            var args = this.visit(call.args);
            for (var key in call.args.map) {
                call.args.map[key] = this.visit(call.args.map[key]);
            }
            this['return']--;

            // Built-in
            if (fn.fn) {
                debug('%s is built-in', call);
                ret = this.invokeBuiltin(fn.fn, args);
                // User-defined
            } else if ('function' == fn.nodeName) {
                debug('%s is user-defined', call);
                ret = this.invokeFunction(fn, args);
            }

            this.calling.pop();
            this.ignoreColors = false;
            return ret;
        };

        /**
        * Visit Ident.
        */

        Evaluator.prototype.visitIdent = function (ident) {
            var prop;
            // Property lookup
            if (ident.property) {
                if (prop = this.lookupProperty(ident.name)) {
                    return this.visit(prop.expr.clone());
                }
                return nodes['null'];
                // Lookup
            } else if (ident.val.isNull) {
                var val = this.lookup(ident.name);
                return val ? this.visit(val) : ident;
                // Assign  
            } else {
                this['return']++;
                ident.val = this.visit(ident.val);
                this['return']--;
                this.currentScope.add(ident);
                return ident.val;
            }
        };

        /**
        * Visit BinOp.
        */

        Evaluator.prototype.visitBinOp = function (binop) {
            // Special-case "is defined" pseudo binop
            if ('is defined' == binop.op) return this.isDefined(binop.left);

            this['return']++;
            // Visit operands
            var op = binop.op
    , left = this.visit(binop.left)
    , right = this.visit(binop.right);
            this['return']--;

            // HACK: ternary
            var val = binop.val
    ? this.visit(binop.val)
    : null;

            // Operate
            try {
                return this.visit(left.operate(op, right, val));
            } catch (err) {
                // disregard coercion issues in equality
                // checks, and simply return false
                if ('CoercionError' == err.name) {
                    switch (op) {
                        case '==':
                            return nodes['false'];
                        case '!=':
                            return nodes['true'];
                    }
                }
                throw err;
            }
        };

        /**
        * Visit UnaryOp.
        */

        Evaluator.prototype.visitUnaryOp = function (unary) {
            var op = unary.op
    , node = this.visit(unary.expr);

            if ('!' != op) {
                node = node.first.clone();
                utils.assertType(node, 'unit');
            }

            switch (op) {
                case '-':
                    node.val = -node.val;
                    break;
                case '+':
                    node.val = +node.val;
                    break;
                case '~':
                    node.val = ~node.val;
                    break;
                case '!':
                    return node.toBoolean().negate();
            }

            return node;
        };

        /**
        * Visit TernaryOp.
        */

        Evaluator.prototype.visitTernary = function (ternary) {
            var ok = this.visit(ternary.cond).toBoolean();
            return ok.isTrue
    ? this.visit(ternary.trueExpr)
    : this.visit(ternary.falseExpr);
        };

        /**
        * Visit Expression.
        */

        Evaluator.prototype.visitExpression = function (expr) {
            for (var i = 0, len = expr.nodes.length; i < len; ++i) {
                expr.nodes[i] = this.visit(expr.nodes[i]);
            }

            // support (n * 5)px etc
            if (this.castable(expr)) expr = this.cast(expr);

            return expr;
        };

        /**
        * Visit Arguments.
        */

        Evaluator.prototype.visitArguments = Evaluator.prototype.visitExpression;

        /**
        * Visit Property.
        */

        Evaluator.prototype.visitProperty = function (prop) {
            var name = this.interpolate(prop)
    , fn = this.lookup(name)
    , call = fn && 'function' == fn.nodeName
    , literal = ~this.calling.indexOf(name);

            // Function of the same name
            if (call && !literal && !prop.literal) {
                this.calling.push(name);
                var args = nodes.Arguments.fromExpression(utils.unwrap(prop.expr));
                var ret = this.visit(new nodes.Call(name, args));
                this.calling.pop();
                return ret;
                // Regular property
            } else {
                this['return']++;
                prop.name = name;
                prop.literal = true;
                this.property = prop;
                prop.expr = this.visit(prop.expr);
                delete this.property;
                this['return']--;
                return prop;
            }
        };

        /**
        * Visit Root.
        */

        Evaluator.prototype.visitRoot = function (block) {
            for (var i = 0; i < block.nodes.length; ++i) {
                block.index = this.rootIndex = i;
                block.nodes[i] = this.visit(block.nodes[i]);
            }
            return block;
        };

        /**
        * Visit Block.
        */

        Evaluator.prototype.visitBlock = function (block) {
            this.stack.push(new Frame(block));
            for (block.index = 0; block.index < block.nodes.length; ++block.index) {
                try {
                    block.nodes[block.index] = this.visit(block.nodes[block.index]);
                } catch (err) {
                    if ('return' == err.nodeName) {
                        if (this['return']) {
                            this.stack.pop();
                            throw err;
                        } else {
                            block.nodes[block.index] = err;
                            break;
                        }
                    } else {
                        throw err;
                    }
                }
            }
            this.stack.pop();
            return block;
        };

        /**
        * Visit If.
        */

        Evaluator.prototype.visitIf = function (node) {
            var ret
    , block = this.currentBlock
    , negate = node.negate;

            this['return']++;
            var ok = this.visit(node.cond).first.toBoolean();
            this['return']--;

            // Evaluate body
            if (negate) {
                // unless
                if (ok.isFalse) {
                    ret = this.visit(node.block);
                }
            } else {
                // if
                if (ok.isTrue) {
                    ret = this.visit(node.block);
                    // else
                } else if (node.elses.length) {
                    var elses = node.elses
        , len = elses.length;
                    for (var i = 0; i < len; ++i) {
                        // else if
                        if (elses[i].cond) {
                            if (this.visit(elses[i].cond).first.toBoolean().isTrue) {
                                ret = this.visit(elses[i].block);
                                break;
                            }
                            // else 
                        } else {
                            ret = this.visit(elses[i]);
                        }
                    }
                }
            }

            // mixin conditional statements within a selector group
            if (ret && !node.postfix && block.node && 'group' == block.node.nodeName) {
                this.mixin(ret.nodes, block);
                return nodes['null'];
            }

            return ret || nodes['null'];
        };

        /**
        * Visit Extend.
        */

        Evaluator.prototype.visitExtend = function (extend) {
            var selector = extend.selector;
            this.currentBlock.node['extends'].push(selector);
            return nodes['null'];
        };

        /**
        * Visit Import.
        */

        Evaluator.prototype.visitImport = function (imported) {
            this['return']++;

            var root = this.root
    , Parser = require('../parser')
    , path = this.visit(imported.path).first
    , includeCSS = this.includeCSS
    , found
    , literal;

            this['return']--;
            debug('import %s', path);

            // url() passed
            if ('url' == path.name) return imported;

            // Enusre string
            if (!path.string) throw new Error('@import string expected');
            var name = path = path.string;

            // Literal
            if (~path.indexOf('.css')) {
                literal = true;
                if (!includeCSS) return imported;
            }

            // support optional .styl
            if (!literal && ! ~path.indexOf('.styl')) path += '.styl';

            // Lookup
            found = utils.lookup(path, this.paths, this.filename);
            found = found || utils.lookup(join(name, 'index.styl'), this.paths, this.filename);

            // Expose imports
            imported.path = found;
            imported.dirname = dirname(found);
            this.paths.push(imported.dirname);
            if (this.options._imports) this.options._imports.push(imported);

            // Throw if import failed
            if (!found) throw new Error('failed to locate @import file ' + path);

            // Parse the file
            this.importStack.push(found);
            nodes.filename = found;

            var str = fs.readFileSync(found, 'utf8');
            if (literal) return new nodes.Literal(str);

            // parse
            var block = new nodes.Block
    , parser = new Parser(str, utils.merge({ root: block }, this.options));

            try {
                block = parser.parse();
            } catch (err) {
                err.filename = found;
                err.lineno = parser.lexer.lineno;
                err.input = str;
                throw err;
            }

            // Store the modified time
            fs.stat(found, function (err, stat) {
                if (err) return;
                imported.mtime = stat.mtime;
            });

            // Evaluate imported "root"
            block.parent = root;
            block.scope = false;
            var ret = this.visit(block);
            this.paths.pop();
            this.importStack.pop();

            return ret;
        };

        /**
        * Invoke `fn` with `args`.
        *
        * @param {Function} fn
        * @param {Array} args
        * @return {Node}
        * @api private
        */

        Evaluator.prototype.invokeFunction = function (fn, args) {
            var block = new nodes.Block(fn.block.parent);
            fn.block.parent = block;

            // Clone the function body
            // to prevent mutation of subsequent calls
            var body = fn.block.clone();

            // mixin block
            var mixinBlock = this.stack.currentFrame.block;

            // new block scope
            this.stack.push(new Frame(block));
            var scope = this.currentScope;

            // arguments local
            scope.add(new nodes.Ident('arguments', args));

            // mixin scope introspection
            scope.add(new nodes.Ident('mixin', this['return']
    ? nodes['false']
    : new nodes.String(mixinBlock.nodeName)));

            // current property
            if (this.property) {
                var prop = this.propertyExpression(this.property, fn.name);
                scope.add(new nodes.Ident('current-property', prop));
            } else {
                scope.add(new nodes.Ident('current-property', nodes['null']));
            }

            // inject arguments as locals
            var i = 0
    , len = args.nodes.length;
            fn.params.nodes.forEach(function (node) {
                // rest param support
                if (node.rest) {
                    node.val = new nodes.Expression;
                    for (; i < len; ++i) node.val.push(args.nodes[i]);
                    node.val.preserve = true;
                    // argument default support
                } else {
                    var arg = args.map[node.name] || args.nodes[i++];
                    node = node.clone();
                    if (arg) {
                        if (!arg.isEmpty) node.val = arg;
                    } else {
                        args.push(node.val);
                    }

                    // required argument not satisfied
                    if (node.val.isNull) {
                        throw new Error('argument "' + node + '" required for ' + fn);
                    }
                }

                scope.add(node);
            });

            // invoke
            return this.invoke(body, true);
        };

        /**
        * Invoke built-in `fn` with `args`.
        *
        * @param {Function} fn
        * @param {Array} args
        * @return {Node}
        * @api private
        */

        Evaluator.prototype.invokeBuiltin = function (fn, args) {
            // Map arguments to first node
            // providing a nicer js api for
            // BIFs. Functions may specify that
            // they wish to accept full expressions
            // via .raw
            if (fn.raw) {
                args = args.nodes;
            } else {
                args = utils.params(fn).reduce(function (ret, param) {
                    var arg = args.map[param] || args.nodes.shift();
                    if (arg) ret.push(arg.first);
                    return ret;
                }, []);
            }

            // Invoke the BIF
            var body = utils.coerce(fn.apply(this, args));

            // Always wrapping allows js functions
            // to return several values with a single
            // Expression node
            var expr = new nodes.Expression;
            expr.push(body);
            body = expr;

            // Invoke
            return this.invoke(body);
        };

        /**
        * Invoke the given function `body`.
        *
        * @param {Block} body
        * @return {Node}
        * @api private
        */

        Evaluator.prototype.invoke = function (body, stack) {
            var self = this
    , ret;

            // Return
            if (this['return']) {
                ret = this.eval(body.nodes);
                if (stack) this.stack.pop();
                // Mixin
            } else {
                var targetFrame = this.stack[this.stack.length - 2];
                if (targetFrame) this.targetBlock = targetFrame.block;
                body = this.visit(body);
                if (stack) this.stack.pop();
                this.mixin(body.nodes, this.currentBlock);
                ret = nodes['null'];
            }

            return ret;
        };

        /**
        * Mixin the given `nodes` to the given `block`.
        *
        * @param {Array} nodes
        * @param {Block} block
        * @api private
        */

        Evaluator.prototype.mixin = function (nodes, block) {
            var len = block.nodes.length
    , head = block.nodes.slice(0, block.index)
    , tail = block.nodes.slice(block.index + 1, len);
            this._mixin(nodes, head);
            block.nodes = head.concat(tail);
        };

        /**
        * Mixin the given `nodes` to the `dest` array.
        *
        * @param {Array} nodes
        * @param {Array} dest
        * @api private
        */

        Evaluator.prototype._mixin = function (nodes, dest) {
            var node
    , len = nodes.length;
            for (var i = 0; i < len; ++i) {
                switch ((node = nodes[i]).nodeName) {
                    case 'return':
                        return;
                    case 'block':
                        this._mixin(node.nodes, dest);
                        break;
                    default:
                        dest.push(node);
                }
            }
        };

        /**
        * Evaluate the given `vals`.
        *
        * @param {Array} vals
        * @return {Node}
        * @api private
        */

        Evaluator.prototype.eval = function (vals) {
            if (!vals) return nodes['null'];
            var len = vals.length
    , node = nodes['null'];

            try {
                for (var i = 0; i < len; ++i) {
                    node = vals[i];
                    switch (node.nodeName) {
                        case 'if':
                            if ('block' != node.block.nodeName) {
                                node = this.visit(node);
                                break;
                            }
                        case 'each':
                        case 'block':
                            node = this.visit(node);
                            if (node.nodes) node = this.eval(node.nodes);
                            break;
                        default:
                            node = this.visit(node);
                    }
                }
            } catch (err) {
                if ('return' == err.nodeName) {
                    return err.expr;
                } else {
                    throw err;
                }
            }

            return node;
        };

        /**
        * Literal function `call`.
        *
        * @param {Call} call
        * @return {call}
        * @api private
        */

        Evaluator.prototype.literalCall = function (call) {
            call.args = this.visit(call.args);
            return call;
        };

        /**
        * Lookup property `name`.
        *
        * @param {String} name
        * @return {Property}
        * @api private
        */

        Evaluator.prototype.lookupProperty = function (name) {
            var i = this.stack.length
    , prop = this.property
    , curr = prop && prop.name
    , index = this.currentBlock.index
    , top = i
    , nodes
    , block
    , other;

            while (i--) {
                block = this.stack[i].block;
                if (!block.node) continue;
                switch (block.node.nodeName) {
                    case 'group':
                    case 'function':
                        nodes = block.nodes;
                        // scan siblings from the property index up
                        if (i + 1 == top) {
                            while (index--) {
                                other = this.interpolate(nodes[index]);
                                if (name == other) return nodes[index].clone();
                            }
                            // sequential lookup for non-siblings (for now)
                        } else {
                            for (var j = 0, len = nodes.length; j < len; ++j) {
                                if ('property' != nodes[j].nodeName) continue;
                                other = this.interpolate(nodes[j]);
                                if (name == other) return nodes[j].clone();
                            }
                        }
                        break;
                }
            }

            return nodes['null'];
        };

        /**
        * Return the closest mixin-able `Block`.
        *
        * @return {Block}
        * @api private
        */

        Object.defineProperty(Evaluator.prototype, 'closestBlock', { configurable: true,
            get: function () {
                var i = this.stack.length
    , block;
                while (i--) {
                    block = this.stack[i].block;
                    if (block.node) {
                        switch (block.node.nodeName) {
                            case 'group':
                            case 'function':
                                return block;
                        }
                    }
                }
            } 
        });

        /**
        * Lookup `name`, with support for JavaScript
        * functions, and BIFs.
        *
        * @param {String} name
        * @return {Node}
        * @api private
        */

        Evaluator.prototype.lookup = function (name) {
            var val;
            if (this.ignoreColors && name in colors) return;
            if (val = this.stack.lookup(name)) {
                return utils.unwrap(val);
            } else {
                return this.lookupFunction(name);
            }
        };

        /**
        * Map segments in `node` returning a string.
        *
        * @param {Node} node
        * @return {String}
        * @api private
        */

        Evaluator.prototype.interpolate = function (node) {
            var self = this;
            return node.segments.map(function (node) {
                function toString(node) {
                    switch (node.nodeName) {
                        case 'function':
                        case 'ident':
                            return node.name;
                        case 'literal':
                        case 'string':
                        case 'unit':
                            return node.val;
                        case 'expression':
                            self['return']++;
                            var ret = toString(self.visit(node).first);
                            self['return']--;
                            return ret;
                    }
                }
                return toString(node);
            }).join('');
        };

        /**
        * Lookup JavaScript user-defined or built-in function.
        *
        * @param {String} name
        * @return {Function}
        * @api private
        */

        Evaluator.prototype.lookupFunction = function (name) {
            var fn = this.functions[name] || bifs[name];
            if (fn) return new nodes.Function(name, fn);
        };

        /**
        * Check if the given `node` is an ident, and if it is defined.
        *
        * @param {Node} node
        * @return {Boolean}
        * @api private
        */

        Evaluator.prototype.isDefined = function (node) {
            if ('ident' == node.nodeName) {
                return nodes.Boolean(this.lookup(node.name));
            } else {
                throw new Error('invalid "is defined" check on non-variable ' + node);
            }
        };

        /**
        * Return `Expression` based on the given `prop`,
        * replacing cyclic calls to the given function `name`
        * with "__CALL__".
        *
        * @param {Property} prop
        * @param {String} name
        * @return {Expression}
        * @api private
        */

        Evaluator.prototype.propertyExpression = function (prop, name) {
            var expr = new nodes.Expression
    , val = prop.expr.clone();

            // name
            expr.push(new nodes.String(prop.name));

            // replace cyclic call with __CALL__
            function replace(node) {
                if ('call' == node.nodeName && name == node.name) {
                    return new nodes.Literal('__CALL__');
                }

                if (node.nodes) node.nodes = node.nodes.map(replace);
                return node;
            }

            replace(val);
            expr.push(val);
            return expr;
        };

        /**
        * Cast `expr` to the trailing ident.
        *
        * @param {Expression} expr
        * @return {Unit}
        * @api private
        */

        Evaluator.prototype.cast = function (expr) {
            return new nodes.Unit(expr.first.val, expr.nodes[1].name);
        };

        /**
        * Check if `expr` is castable.
        *
        * @param {Expression} expr
        * @return {Boolean}
        * @api private
        */

        Evaluator.prototype.castable = function (expr) {
            return 2 == expr.nodes.length
    && 'unit' == expr.first.nodeName
    && ~units.indexOf(expr.nodes[1].name);
        };

        /**
        * Warn with the given `msg`.
        *
        * @param {String} msg
        * @api private
        */

        Evaluator.prototype.warn = function (msg) {
            if (!this.warnings) return;
            console.warn('[33mWarning:[0m ' + msg);
        };

        /**
        * Return the current `Block`.
        *
        * @return {Block}
        * @api private
        */

        Object.defineProperty(Evaluator.prototype, 'currentBlock', { configurable: true,
            get: function () {
                return this.stack.currentFrame.block;
            } 
        });

        /**
        * Return an array of vendor names.
        *
        * @return {Array}
        * @api private
        */

        Object.defineProperty(Evaluator.prototype, 'vendors', { configurable: true,
            get: function () {
                return this.lookup('vendors').nodes.map(function (node) {
                    return node.string;
                });
            } 
        });

        /**
        * Return the current frame `Scope`.
        *
        * @return {Scope}
        * @api private
        */

        Object.defineProperty(Evaluator.prototype, 'currentScope', { configurable: true,
            get: function () {
                return this.stack.currentFrame.scope;
            } 
        });

        /**
        * Return the current `Frame`.
        *
        * @return {Frame}
        * @api private
        */

        Object.defineProperty(Evaluator.prototype, 'currentFrame', { configurable: true,
            get: function () {
                return this.stack.currentFrame;
            } 
        });
    }); // module: visitor/evaluator.js


    require.register("visitor/compiler.js", function (module, exports, require) {

        /*!
        * Stylus - Compiler
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Visitor = require('./')
  , nodes = require('../nodes')
  , utils = require('../utils')
  , fs = require('fs');

        /**
        * Initialize a new `Compiler` with the given `root` Node
        * and the following `options`.
        *
        * Options:
        *
        *   - `compress`  Compress the css output, defaults to false
        *
        * @param {Node} root
        * @api public
        */

        var Compiler = module.exports = function Compiler(root, options) {
            options = options || {};
            this.compress = options.compress;
            this.firebug = options.firebug;
            this.linenos = options.linenos;
            this.spaces = options['indent spaces'] || 2;
            this.indents = 1;
            Visitor.call(this, root);
            this.stack = [];
            this.js = '';
        };

        /**
        * Inherit from `Visitor.prototype`.
        */

        Compiler.prototype.__proto__ = Visitor.prototype;

        /**
        * Compile to css, and return a string of CSS.
        *
        * @return {String}
        * @api private
        */

        Compiler.prototype.compile = function () {
            return this.visit(this.root);
        };

        /**
        * Return indentation string.
        *
        * @return {String}
        * @api private
        */

        Object.defineProperty(Compiler.prototype, 'indent', { configurable: true,
            get: function () {
                if (this.compress) return '';
                return new Array(this.indents).join(Array(this.spaces + 1).join(' '));
            } 
        });

        /**
        * Visit Root.
        */

        Compiler.prototype.visitRoot = function (block) {
            this.buf = '';
            for (var i = 0, len = block.nodes.length; i < len; ++i) {
                var node = block.nodes[i];
                if (this.linenos || this.firebug) this.debugInfo(node);
                var ret = this.visit(node);
                if (ret) this.buf += ret + '\n';
            }
            return this.buf;
        };

        /**
        * Visit Block.
        */

        Compiler.prototype.visitBlock = function (block) {
            var node;

            if (block.hasProperties) {
                var arr = [this.compress ? '{' : ' {'];
                ++this.indents;
                for (var i = 0, len = block.nodes.length; i < len; ++i) {
                    this.last = len - 1 == i;
                    node = block.nodes[i];
                    switch (node.nodeName) {
                        case 'null':
                        case 'expression':
                        case 'function':
                        case 'jsliteral':
                        case 'group':
                        case 'unit':
                            continue;
                        case 'media':
                            // Prevent double-writing the @media declaration when
                            // nested inside of a function/mixin
                            if (node.block.parent.scope) {
                                continue;
                            }
                        default:
                            arr.push(this.visit(node));
                    }
                }
                --this.indents;
                arr.push(this.indent + '}');
                this.buf += arr.join(this.compress ? '' : '\n');
                this.buf += '\n';
            }

            // Nesting
            for (var i = 0, len = block.nodes.length; i < len; ++i) {
                node = block.nodes[i];
                switch (node.nodeName) {
                    case 'group':
                    case 'print':
                    case 'page':
                    case 'block':
                    case 'keyframes':
                        if (this.linenos || this.firebug) this.debugInfo(node);
                        this.visit(node);
                        break;
                    case 'media':
                    case 'import':
                    case 'fontface':
                        this.visit(node);
                        break;
                }
            }
        };

        /**
        * Visit Keyframes.
        */

        Compiler.prototype.visitKeyframes = function (node) {
            var comma = this.compress ? ',' : ', ';

            var prefix = 'official' == node.prefix
    ? ''
    : '-' + node.prefix + '-';

            this.buf += '@' + prefix + 'keyframes '
    + this.visit(node.name)
    + (this.compress ? '{' : ' {');

            ++this.indents;
            node.frames.forEach(function (frame) {
                if (!this.compress) this.buf += '\n  ';
                this.buf += this.visit(frame.pos.join(comma));
                this.visit(frame.block);
            }, this);
            --this.indents;

            this.buf += '}' + (this.compress ? '' : '\n');
        };

        /**
        * Visit Media.
        */

        Compiler.prototype.visitMedia = function (media) {
            this.buf += '@media ' + media.val;
            this.buf += this.compress ? '{' : ' {\n';
            ++this.indents;
            this.visit(media.block);
            --this.indents;
            this.buf += '}' + (this.compress ? '' : '\n');
        };

        /**
        * Visit Page.
        */

        Compiler.prototype.visitPage = function (page) {
            this.buf += this.indent + '@page';
            this.buf += page.selector ? ' ' + page.selector : '';
            this.visit(page.block);
        };

        /**
        * Visit Import.
        */

        Compiler.prototype.visitImport = function (imported) {
            this.buf += '@import ' + this.visit(imported.path) + ';\n';
        };

        /**
        * Visit FontFace.
        */

        Compiler.prototype.visitFontFace = function (face) {
            this.buf += this.indent + '@font-face';
            this.visit(face.block);
        };

        /**
        * Visit JSLiteral.
        */

        Compiler.prototype.visitJSLiteral = function (js) {
            this.js += '\n' + js.val.replace(/@selector/g, '"' + this.selector + '"');
            return '';
        };

        /**
        * Visit Comment.
        */

        Compiler.prototype.visitComment = function (comment) {
            return this.compress
    ? comment.suppress
      ? ''
      : comment.str
    : comment.str;
        };

        /**
        * Visit Function.
        */

        Compiler.prototype.visitFunction = function (fn) {
            return fn.name;
        };

        /**
        * Visit Variable.
        */

        Compiler.prototype.visitVariable = function (variable) {
            return '';
        };

        /**
        * Visit Charset.
        */

        Compiler.prototype.visitCharset = function (charset) {
            return '@charset ' + this.visit(charset.val) + ';';
        };

        /**
        * Visit Literal.
        */

        Compiler.prototype.visitLiteral = function (lit) {
            return lit.val.trim().replace(/^  /gm, '');
        };

        /**
        * Visit Boolean.
        */

        Compiler.prototype.visitBoolean = function (bool) {
            return bool.toString();
        };

        /**
        * Visit RGBA.
        */

        Compiler.prototype.visitRGBA = function (rgba) {
            return rgba.toString();
        };

        /**
        * Visit HSLA.
        */

        Compiler.prototype.visitHSLA = function (hsla) {
            return hsla.rgba.toString();
        };

        /**
        * Visit Unit.
        */

        Compiler.prototype.visitUnit = function (unit) {
            var type = unit.type || ''
    , n = unit.val
    , isFloat = n != (n | 0);

            // Compress
            if (this.compress) {
                // Zero is always '0', unless when
                // a percentage, this is required by keyframes
                if ('%' != type && 0 == n) return '0';
                // Omit leading '0' on floats
                if (isFloat && n < 1 && n > -1) {
                    return n.toString().replace('0.', '.') + type;
                }
            }

            return n.toString() + type;
        };

        /**
        * Visit Group.
        */

        Compiler.prototype.visitGroup = function (group) {
            var stack = this.stack;

            stack.push(group.nodes);

            // selectors
            if (group.block.hasProperties) {
                var selectors = this.compileSelectors(stack);
                this.buf += (this.selector = selectors.join(this.compress ? ',' : ',\n'));
            }

            // output block
            this.visit(group.block);
            stack.pop();
        };

        /**
        * Visit Ident.
        */

        Compiler.prototype.visitIdent = function (ident) {
            return ident.name;
        };

        /**
        * Visit String.
        */

        Compiler.prototype.visitString = function (string) {
            return this.isURL
    ? string.val
    : string.toString();
        };

        /**
        * Visit Null.
        */

        Compiler.prototype.visitNull = function (node) {
            return '';
        };

        /**
        * Visit Call.
        */

        Compiler.prototype.visitCall = function (call) {
            this.isURL = 'url' == call.name;
            var args = call.args.nodes.map(function (arg) {
                return this.visit(arg);
            }, this).join(this.compress ? ',' : ', ');
            if (this.isURL) args = '"' + args + '"';
            delete this.isURL;
            return call.name + '(' + args + ')';
        };

        /**
        * Visit Expression.
        */

        Compiler.prototype.visitExpression = function (expr) {
            var buf = []
    , self = this
    , len = expr.nodes.length
    , nodes = expr.nodes.map(function (node) { return self.visit(node); });

            nodes.forEach(function (node, i) {
                var last = i == len - 1;
                buf.push(node);
                if ('/' == nodes[i + 1] || '/' == node) return;
                if (last) return;
                buf.push(expr.isList
      ? (self.compress ? ',' : ', ')
      : (self.isURL ? '' : ' '));
            });

            return buf.join('');
        };

        /**
        * Visit Arguments.
        */

        Compiler.prototype.visitArguments = Compiler.prototype.visitExpression;

        /**
        * Visit Property.
        */

        Compiler.prototype.visitProperty = function (prop) {
            var self = this
    , val = this.visit(prop.expr).trim();
            return this.indent + (prop.name || prop.segments.join(''))
    + (this.compress ? ':' + val : ': ' + val)
    + (this.compress
        ? (this.last ? '' : ';')
        : ';');
        };

        /**
        * Compile selector strings in `arr` from the bottom-up
        * to produce the selector combinations. For example
        * the following Stylus:
        *
        *    ul
        *      li
        *      p
        *        a
        *          color: red
        *
        * Would return:
        *
        *      [ 'ul li a', 'ul p a' ]
        *
        * @param {Array} arr
        * @return {Array}
        * @api private
        */

        Compiler.prototype.compileSelectors = function (arr) {
            var stack = this.stack
    , self = this
    , selectors = []
    , buf = [];

            function compile(arr, i) {
                if (i) {
                    arr[i].forEach(function (selector) {
                        if (selector.inherits) {
                            buf.unshift(selector.val);
                            compile(arr, i - 1);
                            buf.shift();
                        } else {
                            selectors.push(selector.val);
                        }
                    });
                } else {
                    arr[0].forEach(function (selector) {
                        var str = selector.val.trim();
                        if (buf.length) {
                            for (var i = 0, len = buf.length; i < len; ++i) {
                                if (~buf[i].indexOf('&')) {
                                    str = buf[i].replace(/&/g, str).trim();
                                } else {
                                    str += ' ' + buf[i].trim();
                                }
                            }
                        }
                        selectors.push(self.indent + str.trimRight());
                    });
                }
            }

            compile(arr, arr.length - 1);

            return selectors;
        };

        /**
        * Debug info.
        */

        Compiler.prototype.debugInfo = function (node) {

            var path = fs.realpathSync(node.filename)
    , line = node.nodes ? node.nodes[0].lineno : node.lineno;

            if (this.linenos) {
                this.buf += '\n/* ' + 'line ' + line + ' : ' + path + ' */\n';
            }

            if (this.firebug) {
                // debug info for firebug, the crazy formatting is needed
                path = 'file\\\:\\\/\\\/' + path.replace(/(\/|\.)/g, '\\$1');
                line = '\\00003' + line;
                this.buf += '\n@media -stylus-debug-info'
      + '{filename{font-family:' + path
      + '}line{font-family:' + line + '}}\n';
            }
        }

        Compiler.prototype.visitRoot = function (block) {
            this.buf = '';
            for (var i = 0, len = block.nodes.length; i < len; ++i) {
                var node = block.nodes[i];
                if (this.linenos || this.firebug) {
                    this.debugInfo(node);
                }

                //        var ret = this.visit(node);
                //        if (ret) this.buf += ret + '\n';

                switch (node.nodeName) {
                    case 'null':
                    case 'expression':
                    case 'function':
                    case 'jsliteral':
                    case 'unit':
                        continue;
                    default:
                        var ret = this.visit(node);
                        if (ret) this.buf += ret + '\n';
                }
            }
            return this.buf;
        };
    }); // module: visitor/compiler.js


    require.register("stylus.js", function (module, exports, require) {


        /*!
        * Stylus
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Renderer = require('./renderer')
  , Parser = require('./parser')
  , nodes = require('./nodes')
  , utils = require('./utils');

        /**
        * Export render as the module.
        */

        exports = module.exports = render;

        /**
        * Library version.
        */

        exports.version = '0.25.0';

        /**
        * Expose nodes.
        */

        exports.nodes = nodes;

        /**
        * Expose BIFs.
        */

        exports['Functions'] = require('./functions');

        /**
        * Expose utils.
        */

        exports.utils = require('./utils');

        /**
        * Expose middleware.
        */

        exports.middleware = require('./middleware');

        /**
        * Expose constructors.
        */

        exports.Visitor = require('./visitor');
        exports.Parser = require('./parser');
        exports.Evaluator = require('./visitor/evaluator');
        exports.Compiler = require('./visitor/compiler');

        /**
        * Convert the given `css` to `stylus` source.
        *
        * @param {String} css
        * @return {String}
        * @api public
        */

        exports.convertCSS = require('./convert/css');

        /**
        * Render the given `str` with `options` and callback `fn(err, css)`.
        *
        * @param {String} str
        * @param {Object|Function} options
        * @param {Function} fn
        * @api public
        */

        exports.render = function (str, options, fn) {
            if ('function' == typeof options) fn = options, options = {};
            new Renderer(str, options).render(fn);
        };

        /**
        * Return a new `Renderer` for the given `str` and `options`.
        *
        * @param {String} str
        * @param {Object} options
        * @return {Renderer}
        * @api public
        */

        function render(str, options) {
            return new Renderer(str, options);
        }

        /**
        * Expose optional functions.
        */

        exports.url = require('./functions/url');

        function render(str, options) {
            str = bifs + str;
            return new Renderer(str, options);
        }
    }); // module: stylus.js


    require.register("renderer.js", function (module, exports, require) {


        /*!
        * Stylus - Renderer
        * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
        * MIT Licensed
        */

        /**
        * Module dependencies.
        */

        var Parser = require('./parser')
  , EventEmitter = require('events').EventEmitter
  , Compiler = require('./visitor/compiler')
  , Evaluator = require('./visitor/evaluator')
  , Normalizer = require('./visitor/normalizer')
  , utils = require('./utils')
  , nodes = require('./nodes')
  , path = require('path')
  , join = path.join;

        /**
        * Expose `Renderer`.
        */

        module.exports = Renderer;

        /**
        * Initialize a new `Renderer` with the given `str` and `options`.
        *
        * @param {String} str
        * @param {Object} options
        * @api public
        */

        function Renderer(str, options) {
            options = options || {};
            options.globals = {};
            options.functions = {};
            options.imports = [join(__dirname, 'functions')];
            options.paths = options.paths || [];
            options.filename = options.filename || 'stylus';
            this.options = options;
            this.str = str;
        };

        /**
        * Inherit from `EventEmitter.prototype`.
        */

        Renderer.prototype.__proto__ = EventEmitter.prototype;

        /**
        * Parse and evaluate AST, then callback `fn(err, css, js)`.
        *
        * @param {Function} fn
        * @api public
        */

        Renderer.prototype.render = function (fn) {
            var parser = this.parser = new Parser(this.str, this.options);
            try {
                nodes.filename = this.options.filename;
                // parse
                var ast = parser.parse();

                // evaluate
                this.evaluator = new Evaluator(ast, this.options);
                ast = this.evaluator.evaluate();

                // normalize
                var normalizer = new Normalizer(ast, this.options);
                ast = normalizer.normalize();

                // compile
                var compiler = new Compiler(ast, this.options)
      , css = compiler.compile();

                this.emit('end', css);
                fn(null, css);
            } catch (err) {
                var options = {};
                options.input = err.input || this.str;
                options.filename = err.filename || this.options.filename;
                options.lineno = err.lineno || parser.lexer.lineno;
                fn(utils.formatException(err, options));
            }
        };

        /**
        * Set option `key` to `val`.
        *
        * @param {String} key
        * @param {Mixed} val
        * @return {Renderer} for chaining
        * @api public
        */

        Renderer.prototype.set = function (key, val) {
            this.options[key] = val;
            return this;
        };

        /**
        * Get option `key`.
        *
        * @param {String} key
        * @return {Mixed} val
        * @api public
        */

        Renderer.prototype.get = function (key) {
            return this.options[key];
        };

        /**
        * Include the given `path` to the lookup paths array.
        *
        * @param {String} path
        * @return {Renderer} for chaining
        * @api public
        */

        Renderer.prototype.include = function (path) {
            this.options.paths.push(path);
            return this;
        };

        /**
        * Use the given `fn`.
        *
        * This allows for plugins to alter the renderer in
        * any way they wish, exposing paths etc.
        *
        * @param {Function}
        * @return {Renderer} for chaining
        * @api public
        */

        Renderer.prototype.use = function (fn) {
            fn.call(this, this);
            return this;
        };

        /**
        * Define function or global var with the given `name`. Optionally
        * the function may accept full expressions, by setting `raw`
        * to `true`.
        *
        * @param {String} name
        * @param {Function|Node} fn
        * @return {Renderer} for chaining
        * @api public
        */

        Renderer.prototype.define = function (name, fn, raw) {
            fn = utils.coerce(fn);

            if (fn.nodeName) {
                this.options.globals[name] = fn;
                return this;
            }

            // function
            this.options.functions[name] = fn;
            if (undefined != raw) fn.raw = raw;
            return this;
        };

        /**
        * Import the given `file`.
        *
        * @param {String} file
        * @return {Renderer} for chaining
        * @api public
        */

        Renderer.prototype['import'] = function (file) {
            this.options.imports.push(file);
            return this;
        };



        function Renderer(str, options) {
            options = options || {};
            options.globals = {};
            options.functions = {};
            //options.imports = [join(__dirname, 'functions')];
            options.imports = [];
            options.paths = options.paths || [];
            options.filename = options.filename || 'stylus';
            this.options = options;
            this.str = str;
        }

    }); // module: renderer.js

    return require('stylus');
})();


function compilify_stylus(stylus_code) {
    var rend = stylus(stylus_code);
    rend.imports = [];
    rend.render(function (err, css) {
        if (err) {
            throw err;
            return;
        }
        return css;
    });
}